Cloudera Altus Director API

Authentication

login

/api/v8/login

Usage and SDK Samples

curl -X POST "https://localhost/api/v8/login"

import com.cloudera.director.client.common.*;
import com.cloudera.director.client.common.auth.*;
import com.cloudera.director.client.common.model.*;
import com.cloudera.director.client.common.api.AuthenticationApi;

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

public class AuthenticationApiExample {

    public static void main(String[] args) {
        
        AuthenticationApi apiInstance = new AuthenticationApi();
        Login login = ; // Login | 
        try {
            User result = apiInstance.login(login);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthenticationApi#login");
            e.printStackTrace();
        }
    }
}

import com.cloudera.director.client.common.api.AuthenticationApi;

public class AuthenticationApiExample {

    public static void main(String[] args) {
        AuthenticationApi apiInstance = new AuthenticationApi();
        Login login = ; // Login | 
        try {
            User result = apiInstance.login(login);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthenticationApi#login");
            e.printStackTrace();
        }
    }
}

Login *login = ; // 

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

// Log in to the API
[apiInstance loginWith:login
              completionHandler: ^(User output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaAltusDirectorApi = require('cloudera_altus_director_api');

var api = new ClouderaAltusDirectorApi.AuthenticationApi()

var login = ; // {Login} 


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

using System;
using System.Diagnostics;
using cloudera.director.Api;
using cloudera.director.Client;
using cloudera.director.Model;

namespace Example
{
    public class loginExample
    {
        public void main()
        {
            
            var apiInstance = new AuthenticationApi();
            var login = new Login(); // Login | 

            try
            {
                // Log in to the API
                User result = apiInstance.login(login);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AuthenticationApi.login: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\AuthenticationApi();
$login = ; // Login | 

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

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

my $api_instance = WWW::SwaggerClient::AuthenticationApi->new();
my $login = WWW::SwaggerClient::Object::Login->new(); # Login | 

eval { 
    my $result = $api_instance->login(login => $login);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AuthenticationApi->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.AuthenticationApi()
login =  # Login | 

try: 
    # Log in to the API
    api_response = api_instance.login(login)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AuthenticationApi->login: %s\n" % e)

Parameters

Body parameters

Name	Description
login *

Responses

Status: 200 - Login successful

Schema

Status: 400 - Invalid login

Status: 401 - Login failed

logout

Log out from the API

/api/v8/logout

Usage and SDK Samples

curl -X POST "https://localhost/api/v8/logout"

import com.cloudera.director.client.common.*;
import com.cloudera.director.client.common.auth.*;
import com.cloudera.director.client.common.model.*;
import com.cloudera.director.client.common.api.AuthenticationApi;

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

public class AuthenticationApiExample {

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

import com.cloudera.director.client.common.api.AuthenticationApi;

public class AuthenticationApiExample {

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


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

// Log out from the API
[apiInstance logoutWithCompletionHandler: 
              ^('Boolean' output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaAltusDirectorApi = require('cloudera_altus_director_api');

var api = new ClouderaAltusDirectorApi.AuthenticationApi()

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

using System;
using System.Diagnostics;
using cloudera.director.Api;
using cloudera.director.Client;
using cloudera.director.Model;

namespace Example
{
    public class logoutExample
    {
        public void main()
        {
            
            var apiInstance = new AuthenticationApi();

            try
            {
                // Log out from the API
                'Boolean' result = apiInstance.logout();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AuthenticationApi.logout: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\AuthenticationApi();

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

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

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

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

try: 
    # Log out from the API
    api_response = api_instance.logout()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AuthenticationApi->logout: %s\n" % e)

Parameters

Responses

Status: 200 - Logout successful

Schema

Status: 401 - Not logged in

Clusters

collectDiagnosticData

Collects diagnostic data

/api/v8/environments/{environment}/deployments/{deployment}/clusters/{cluster}/diagnosticData

Usage and SDK Samples

curl -X POST -H "Accept: application/json" -H "Authorization: Basic [[basicHash]]" "https://localhost/api/v8/environments/{environment}/deployments/{deployment}/clusters/{cluster}/diagnosticData"

import com.cloudera.director.client.common.*;
import com.cloudera.director.client.common.auth.*;
import com.cloudera.director.client.common.model.*;
import com.cloudera.director.client.common.api.ClustersApi;

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

public class ClustersApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        ClustersApi apiInstance = new ClustersApi();
        String environment = environment_example; // String | 
        String deployment = deployment_example; // String | 
        String cluster = cluster_example; // String | 
        try {
            apiInstance.collectDiagnosticData(environment, deployment, cluster);
        } catch (ApiException e) {
            System.err.println("Exception when calling ClustersApi#collectDiagnosticData");
            e.printStackTrace();
        }
    }
}

import com.cloudera.director.client.common.api.ClustersApi;

public class ClustersApiExample {

    public static void main(String[] args) {
        ClustersApi apiInstance = new ClustersApi();
        String environment = environment_example; // String | 
        String deployment = deployment_example; // String | 
        String cluster = cluster_example; // String | 
        try {
            apiInstance.collectDiagnosticData(environment, deployment, cluster);
        } catch (ApiException e) {
            System.err.println("Exception when calling ClustersApi#collectDiagnosticData");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *environment = environment_example; // 
String *deployment = deployment_example; // 
String *cluster = cluster_example; // 

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

// Collects diagnostic data
[apiInstance collectDiagnosticDataWith:environment
    deployment:deployment
    cluster:cluster
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaAltusDirectorApi = require('cloudera_altus_director_api');
var defaultClient = ClouderaAltusDirectorApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new ClouderaAltusDirectorApi.ClustersApi()

var environment = environment_example; // {String} 

var deployment = deployment_example; // {String} 

var cluster = cluster_example; // {String} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.collectDiagnosticData(environment, deployment, cluster, callback);

using System;
using System.Diagnostics;
using cloudera.director.Api;
using cloudera.director.Client;
using cloudera.director.Model;

namespace Example
{
    public class collectDiagnosticDataExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ClustersApi();
            var environment = environment_example;  // String | 
            var deployment = deployment_example;  // String | 
            var cluster = cluster_example;  // String | 

            try
            {
                // Collects diagnostic data
                apiInstance.collectDiagnosticData(environment, deployment, cluster);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ClustersApi.collectDiagnosticData: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ClustersApi();
$environment = environment_example; // String | 
$deployment = deployment_example; // String | 
$cluster = cluster_example; // String | 

try {
    $api_instance->collectDiagnosticData($environment, $deployment, $cluster);
} catch (Exception $e) {
    echo 'Exception when calling ClustersApi->collectDiagnosticData: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ClustersApi->new();
my $environment = environment_example; # String | 
my $deployment = deployment_example; # String | 
my $cluster = cluster_example; # String | 

eval { 
    $api_instance->collectDiagnosticData(environment => $environment, deployment => $deployment, cluster => $cluster);
};
if ($@) {
    warn "Exception when calling ClustersApi->collectDiagnosticData: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ClustersApi()
environment = environment_example # String | 
deployment = deployment_example # String | 
cluster = cluster_example # String | 

try: 
    # Collects diagnostic data
    api_instance.collect_diagnostic_data(environment, deployment, cluster)
except ApiException as e:
    print("Exception when calling ClustersApi->collectDiagnosticData: %s\n" % e)

Parameters

Path parameters

Name	Description
environment*	String Required
deployment*	String Required
cluster*	String Required

Responses

Status: 202 - Accepted

Status: 404 - Entity not found

Status: 409 - Cluster is in transition

Status: 412 - Deployment is not available

create

Create a new cluster

/api/v8/environments/{environment}/deployments/{deployment}/clusters

Usage and SDK Samples

curl -X POST -H "Accept: application/json" -H "Authorization: Basic [[basicHash]]" "https://localhost/api/v8/environments/{environment}/deployments/{deployment}/clusters"

import com.cloudera.director.client.common.*;
import com.cloudera.director.client.common.auth.*;
import com.cloudera.director.client.common.model.*;
import com.cloudera.director.client.common.api.ClustersApi;

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

public class ClustersApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        ClustersApi apiInstance = new ClustersApi();
        String environment = environment_example; // String | 
        String deployment = deployment_example; // String | 
        ClusterTemplate clusterTemplate = ; // ClusterTemplate | 
        try {
            apiInstance.create(environment, deployment, clusterTemplate);
        } catch (ApiException e) {
            System.err.println("Exception when calling ClustersApi#create");
            e.printStackTrace();
        }
    }
}

import com.cloudera.director.client.common.api.ClustersApi;

public class ClustersApiExample {

    public static void main(String[] args) {
        ClustersApi apiInstance = new ClustersApi();
        String environment = environment_example; // String | 
        String deployment = deployment_example; // String | 
        ClusterTemplate clusterTemplate = ; // ClusterTemplate | 
        try {
            apiInstance.create(environment, deployment, clusterTemplate);
        } catch (ApiException e) {
            System.err.println("Exception when calling ClustersApi#create");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *environment = environment_example; // 
String *deployment = deployment_example; // 
ClusterTemplate *clusterTemplate = ; // 

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

// Create a new cluster
[apiInstance createWith:environment
    deployment:deployment
    clusterTemplate:clusterTemplate
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaAltusDirectorApi = require('cloudera_altus_director_api');
var defaultClient = ClouderaAltusDirectorApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new ClouderaAltusDirectorApi.ClustersApi()

var environment = environment_example; // {String} 

var deployment = deployment_example; // {String} 

var clusterTemplate = ; // {ClusterTemplate} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.create(environment, deployment, clusterTemplate, callback);

using System;
using System.Diagnostics;
using cloudera.director.Api;
using cloudera.director.Client;
using cloudera.director.Model;

namespace Example
{
    public class createExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ClustersApi();
            var environment = environment_example;  // String | 
            var deployment = deployment_example;  // String | 
            var clusterTemplate = new ClusterTemplate(); // ClusterTemplate | 

            try
            {
                // Create a new cluster
                apiInstance.create(environment, deployment, clusterTemplate);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ClustersApi.create: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ClustersApi();
$environment = environment_example; // String | 
$deployment = deployment_example; // String | 
$clusterTemplate = ; // ClusterTemplate | 

try {
    $api_instance->create($environment, $deployment, $clusterTemplate);
} catch (Exception $e) {
    echo 'Exception when calling ClustersApi->create: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ClustersApi->new();
my $environment = environment_example; # String | 
my $deployment = deployment_example; # String | 
my $clusterTemplate = WWW::SwaggerClient::Object::ClusterTemplate->new(); # ClusterTemplate | 

eval { 
    $api_instance->create(environment => $environment, deployment => $deployment, clusterTemplate => $clusterTemplate);
};
if ($@) {
    warn "Exception when calling ClustersApi->create: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ClustersApi()
environment = environment_example # String | 
deployment = deployment_example # String | 
clusterTemplate =  # ClusterTemplate | 

try: 
    # Create a new cluster
    api_instance.create(environment, deployment, clusterTemplate)
except ApiException as e:
    print("Exception when calling ClustersApi->create: %s\n" % e)

Parameters

Path parameters

Name	Description
environment*	String Required
deployment*	String Required

Body parameters

Name	Description
clusterTemplate *

Responses

Status: 201 - Cluster template accepted

Status: 302 - Cluster already exists

Status: 400 - Invalid cluster template

delete

Delete a cluster by name

/api/v8/environments/{environment}/deployments/{deployment}/clusters/{cluster}

Usage and SDK Samples

curl -X DELETE -H "Accept: application/json" -H "Authorization: Basic [[basicHash]]" "https://localhost/api/v8/environments/{environment}/deployments/{deployment}/clusters/{cluster}"

import com.cloudera.director.client.common.*;
import com.cloudera.director.client.common.auth.*;
import com.cloudera.director.client.common.model.*;
import com.cloudera.director.client.common.api.ClustersApi;

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

public class ClustersApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        ClustersApi apiInstance = new ClustersApi();
        String environment = environment_example; // String | 
        String deployment = deployment_example; // String | 
        String cluster = cluster_example; // String | 
        try {
            apiInstance.delete(environment, deployment, cluster);
        } catch (ApiException e) {
            System.err.println("Exception when calling ClustersApi#delete");
            e.printStackTrace();
        }
    }
}

import com.cloudera.director.client.common.api.ClustersApi;

public class ClustersApiExample {

    public static void main(String[] args) {
        ClustersApi apiInstance = new ClustersApi();
        String environment = environment_example; // String | 
        String deployment = deployment_example; // String | 
        String cluster = cluster_example; // String | 
        try {
            apiInstance.delete(environment, deployment, cluster);
        } catch (ApiException e) {
            System.err.println("Exception when calling ClustersApi#delete");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *environment = environment_example; // 
String *deployment = deployment_example; // 
String *cluster = cluster_example; // 

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

// Delete a cluster by name
[apiInstance deleteWith:environment
    deployment:deployment
    cluster:cluster
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaAltusDirectorApi = require('cloudera_altus_director_api');
var defaultClient = ClouderaAltusDirectorApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new ClouderaAltusDirectorApi.ClustersApi()

var environment = environment_example; // {String} 

var deployment = deployment_example; // {String} 

var cluster = cluster_example; // {String} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.delete(environment, deployment, cluster, callback);

using System;
using System.Diagnostics;
using cloudera.director.Api;
using cloudera.director.Client;
using cloudera.director.Model;

namespace Example
{
    public class deleteExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ClustersApi();
            var environment = environment_example;  // String | 
            var deployment = deployment_example;  // String | 
            var cluster = cluster_example;  // String | 

            try
            {
                // Delete a cluster by name
                apiInstance.delete(environment, deployment, cluster);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ClustersApi.delete: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ClustersApi();
$environment = environment_example; // String | 
$deployment = deployment_example; // String | 
$cluster = cluster_example; // String | 

try {
    $api_instance->delete($environment, $deployment, $cluster);
} catch (Exception $e) {
    echo 'Exception when calling ClustersApi->delete: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ClustersApi->new();
my $environment = environment_example; # String | 
my $deployment = deployment_example; # String | 
my $cluster = cluster_example; # String | 

eval { 
    $api_instance->delete(environment => $environment, deployment => $deployment, cluster => $cluster);
};
if ($@) {
    warn "Exception when calling ClustersApi->delete: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ClustersApi()
environment = environment_example # String | 
deployment = deployment_example # String | 
cluster = cluster_example # String | 

try: 
    # Delete a cluster by name
    api_instance.delete(environment, deployment, cluster)
except ApiException as e:
    print("Exception when calling ClustersApi->delete: %s\n" % e)

Parameters

Path parameters

Name	Description
environment*	String Required
deployment*	String Required
cluster*	String Required

Responses

Status: 204 - Delete request accepted

Status: 404 - Entity not found

get

Get a cluster by name

/api/v8/environments/{environment}/deployments/{deployment}/clusters/{cluster}

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Authorization: Basic [[basicHash]]" "https://localhost/api/v8/environments/{environment}/deployments/{deployment}/clusters/{cluster}"

import com.cloudera.director.client.common.*;
import com.cloudera.director.client.common.auth.*;
import com.cloudera.director.client.common.model.*;
import com.cloudera.director.client.common.api.ClustersApi;

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

public class ClustersApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        ClustersApi apiInstance = new ClustersApi();
        String environment = environment_example; // String | 
        String deployment = deployment_example; // String | 
        String cluster = cluster_example; // String | 
        try {
            Cluster result = apiInstance.get(environment, deployment, cluster);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ClustersApi#get");
            e.printStackTrace();
        }
    }
}

import com.cloudera.director.client.common.api.ClustersApi;

public class ClustersApiExample {

    public static void main(String[] args) {
        ClustersApi apiInstance = new ClustersApi();
        String environment = environment_example; // String | 
        String deployment = deployment_example; // String | 
        String cluster = cluster_example; // String | 
        try {
            Cluster result = apiInstance.get(environment, deployment, cluster);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ClustersApi#get");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *environment = environment_example; // 
String *deployment = deployment_example; // 
String *cluster = cluster_example; // 

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

// Get a cluster by name
[apiInstance getWith:environment
    deployment:deployment
    cluster:cluster
              completionHandler: ^(Cluster output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaAltusDirectorApi = require('cloudera_altus_director_api');
var defaultClient = ClouderaAltusDirectorApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new ClouderaAltusDirectorApi.ClustersApi()

var environment = environment_example; // {String} 

var deployment = deployment_example; // {String} 

var cluster = cluster_example; // {String} 


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

using System;
using System.Diagnostics;
using cloudera.director.Api;
using cloudera.director.Client;
using cloudera.director.Model;

namespace Example
{
    public class getExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ClustersApi();
            var environment = environment_example;  // String | 
            var deployment = deployment_example;  // String | 
            var cluster = cluster_example;  // String | 

            try
            {
                // Get a cluster by name
                Cluster result = apiInstance.get(environment, deployment, cluster);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ClustersApi.get: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ClustersApi();
$environment = environment_example; // String | 
$deployment = deployment_example; // String | 
$cluster = cluster_example; // String | 

try {
    $result = $api_instance->get($environment, $deployment, $cluster);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ClustersApi->get: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ClustersApi->new();
my $environment = environment_example; # String | 
my $deployment = deployment_example; # String | 
my $cluster = cluster_example; # String | 

eval { 
    my $result = $api_instance->get(environment => $environment, deployment => $deployment, cluster => $cluster);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ClustersApi->get: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ClustersApi()
environment = environment_example # String | 
deployment = deployment_example # String | 
cluster = cluster_example # String | 

try: 
    # Get a cluster by name
    api_response = api_instance.get(environment, deployment, cluster)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ClustersApi->get: %s\n" % e)

Parameters

Path parameters

Name	Description
environment*	String Required
deployment*	String Required
cluster*	String Required

Responses

Status: 200 - OK

Schema

Status: 204 - Cluster is in transition or failed stage

Status: 404 - Entity not found

getMetrics

Get cluster metrics by name

/api/v8/environments/{environment}/deployments/{deployment}/clusters/{cluster}/metrics

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Authorization: Basic [[basicHash]]" "https://localhost/api/v8/environments/{environment}/deployments/{deployment}/clusters/{cluster}/metrics"

import com.cloudera.director.client.common.*;
import com.cloudera.director.client.common.auth.*;
import com.cloudera.director.client.common.model.*;
import com.cloudera.director.client.common.api.ClustersApi;

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

public class ClustersApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        ClustersApi apiInstance = new ClustersApi();
        String environment = environment_example; // String | 
        String deployment = deployment_example; // String | 
        String cluster = cluster_example; // String | 
        try {
            Metrics result = apiInstance.getMetrics(environment, deployment, cluster);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ClustersApi#getMetrics");
            e.printStackTrace();
        }
    }
}

import com.cloudera.director.client.common.api.ClustersApi;

public class ClustersApiExample {

    public static void main(String[] args) {
        ClustersApi apiInstance = new ClustersApi();
        String environment = environment_example; // String | 
        String deployment = deployment_example; // String | 
        String cluster = cluster_example; // String | 
        try {
            Metrics result = apiInstance.getMetrics(environment, deployment, cluster);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ClustersApi#getMetrics");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *environment = environment_example; // 
String *deployment = deployment_example; // 
String *cluster = cluster_example; // 

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

// Get cluster metrics by name
[apiInstance getMetricsWith:environment
    deployment:deployment
    cluster:cluster
              completionHandler: ^(Metrics output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaAltusDirectorApi = require('cloudera_altus_director_api');
var defaultClient = ClouderaAltusDirectorApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new ClouderaAltusDirectorApi.ClustersApi()

var environment = environment_example; // {String} 

var deployment = deployment_example; // {String} 

var cluster = cluster_example; // {String} 


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

using System;
using System.Diagnostics;
using cloudera.director.Api;
using cloudera.director.Client;
using cloudera.director.Model;

namespace Example
{
    public class getMetricsExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ClustersApi();
            var environment = environment_example;  // String | 
            var deployment = deployment_example;  // String | 
            var cluster = cluster_example;  // String | 

            try
            {
                // Get cluster metrics by name
                Metrics result = apiInstance.getMetrics(environment, deployment, cluster);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ClustersApi.getMetrics: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ClustersApi();
$environment = environment_example; // String | 
$deployment = deployment_example; // String | 
$cluster = cluster_example; // String | 

try {
    $result = $api_instance->getMetrics($environment, $deployment, $cluster);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ClustersApi->getMetrics: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ClustersApi->new();
my $environment = environment_example; # String | 
my $deployment = deployment_example; # String | 
my $cluster = cluster_example; # String | 

eval { 
    my $result = $api_instance->getMetrics(environment => $environment, deployment => $deployment, cluster => $cluster);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ClustersApi->getMetrics: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ClustersApi()
environment = environment_example # String | 
deployment = deployment_example # String | 
cluster = cluster_example # String | 

try: 
    # Get cluster metrics by name
    api_response = api_instance.get_metrics(environment, deployment, cluster)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ClustersApi->getMetrics: %s\n" % e)

Parameters

Path parameters

Name	Description
environment*	String Required
deployment*	String Required
cluster*	String Required

Responses

Status: 200 - OK

Schema

Status: 204 - Cluster is in transition or a failed stage

Status: 404 - Entity not found

getStatus

Get a cluster status by name

/api/v8/environments/{environment}/deployments/{deployment}/clusters/{cluster}/status

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Authorization: Basic [[basicHash]]" "https://localhost/api/v8/environments/{environment}/deployments/{deployment}/clusters/{cluster}/status"

import com.cloudera.director.client.common.*;
import com.cloudera.director.client.common.auth.*;
import com.cloudera.director.client.common.model.*;
import com.cloudera.director.client.common.api.ClustersApi;

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

public class ClustersApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        ClustersApi apiInstance = new ClustersApi();
        String environment = environment_example; // String | 
        String deployment = deployment_example; // String | 
        String cluster = cluster_example; // String | 
        try {
            Status result = apiInstance.getStatus(environment, deployment, cluster);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ClustersApi#getStatus");
            e.printStackTrace();
        }
    }
}

import com.cloudera.director.client.common.api.ClustersApi;

public class ClustersApiExample {

    public static void main(String[] args) {
        ClustersApi apiInstance = new ClustersApi();
        String environment = environment_example; // String | 
        String deployment = deployment_example; // String | 
        String cluster = cluster_example; // String | 
        try {
            Status result = apiInstance.getStatus(environment, deployment, cluster);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ClustersApi#getStatus");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *environment = environment_example; // 
String *deployment = deployment_example; // 
String *cluster = cluster_example; // 

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

// Get a cluster status by name
[apiInstance getStatusWith:environment
    deployment:deployment
    cluster:cluster
              completionHandler: ^(Status output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaAltusDirectorApi = require('cloudera_altus_director_api');
var defaultClient = ClouderaAltusDirectorApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new ClouderaAltusDirectorApi.ClustersApi()

var environment = environment_example; // {String} 

var deployment = deployment_example; // {String} 

var cluster = cluster_example; // {String} 


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

using System;
using System.Diagnostics;
using cloudera.director.Api;
using cloudera.director.Client;
using cloudera.director.Model;

namespace Example
{
    public class getStatusExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ClustersApi();
            var environment = environment_example;  // String | 
            var deployment = deployment_example;  // String | 
            var cluster = cluster_example;  // String | 

            try
            {
                // Get a cluster status by name
                Status result = apiInstance.getStatus(environment, deployment, cluster);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ClustersApi.getStatus: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ClustersApi();
$environment = environment_example; // String | 
$deployment = deployment_example; // String | 
$cluster = cluster_example; // String | 

try {
    $result = $api_instance->getStatus($environment, $deployment, $cluster);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ClustersApi->getStatus: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ClustersApi->new();
my $environment = environment_example; # String | 
my $deployment = deployment_example; # String | 
my $cluster = cluster_example; # String | 

eval { 
    my $result = $api_instance->getStatus(environment => $environment, deployment => $deployment, cluster => $cluster);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ClustersApi->getStatus: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ClustersApi()
environment = environment_example # String | 
deployment = deployment_example # String | 
cluster = cluster_example # String | 

try: 
    # Get a cluster status by name
    api_response = api_instance.get_status(environment, deployment, cluster)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ClustersApi->getStatus: %s\n" % e)

Parameters

Path parameters

Name	Description
environment*	String Required
deployment*	String Required
cluster*	String Required

Responses

Status: 200 - OK

Schema

Status: 404 - Entity not found

getTemplateRedacted

Get a cluster template by name

/api/v8/environments/{environment}/deployments/{deployment}/clusters/{cluster}/template

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Authorization: Basic [[basicHash]]" "https://localhost/api/v8/environments/{environment}/deployments/{deployment}/clusters/{cluster}/template"

import com.cloudera.director.client.common.*;
import com.cloudera.director.client.common.auth.*;
import com.cloudera.director.client.common.model.*;
import com.cloudera.director.client.common.api.ClustersApi;

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

public class ClustersApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        ClustersApi apiInstance = new ClustersApi();
        String environment = environment_example; // String | 
        String deployment = deployment_example; // String | 
        String cluster = cluster_example; // String | 
        try {
            ClusterTemplate result = apiInstance.getTemplateRedacted(environment, deployment, cluster);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ClustersApi#getTemplateRedacted");
            e.printStackTrace();
        }
    }
}

import com.cloudera.director.client.common.api.ClustersApi;

public class ClustersApiExample {

    public static void main(String[] args) {
        ClustersApi apiInstance = new ClustersApi();
        String environment = environment_example; // String | 
        String deployment = deployment_example; // String | 
        String cluster = cluster_example; // String | 
        try {
            ClusterTemplate result = apiInstance.getTemplateRedacted(environment, deployment, cluster);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ClustersApi#getTemplateRedacted");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *environment = environment_example; // 
String *deployment = deployment_example; // 
String *cluster = cluster_example; // 

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

// Get a cluster template by name
[apiInstance getTemplateRedactedWith:environment
    deployment:deployment
    cluster:cluster
              completionHandler: ^(ClusterTemplate output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaAltusDirectorApi = require('cloudera_altus_director_api');
var defaultClient = ClouderaAltusDirectorApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new ClouderaAltusDirectorApi.ClustersApi()

var environment = environment_example; // {String} 

var deployment = deployment_example; // {String} 

var cluster = cluster_example; // {String} 


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

using System;
using System.Diagnostics;
using cloudera.director.Api;
using cloudera.director.Client;
using cloudera.director.Model;

namespace Example
{
    public class getTemplateRedactedExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ClustersApi();
            var environment = environment_example;  // String | 
            var deployment = deployment_example;  // String | 
            var cluster = cluster_example;  // String | 

            try
            {
                // Get a cluster template by name
                ClusterTemplate result = apiInstance.getTemplateRedacted(environment, deployment, cluster);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ClustersApi.getTemplateRedacted: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ClustersApi();
$environment = environment_example; // String | 
$deployment = deployment_example; // String | 
$cluster = cluster_example; // String | 

try {
    $result = $api_instance->getTemplateRedacted($environment, $deployment, $cluster);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ClustersApi->getTemplateRedacted: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ClustersApi->new();
my $environment = environment_example; # String | 
my $deployment = deployment_example; # String | 
my $cluster = cluster_example; # String | 

eval { 
    my $result = $api_instance->getTemplateRedacted(environment => $environment, deployment => $deployment, cluster => $cluster);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ClustersApi->getTemplateRedacted: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ClustersApi()
environment = environment_example # String | 
deployment = deployment_example # String | 
cluster = cluster_example # String | 

try: 
    # Get a cluster template by name
    api_response = api_instance.get_template_redacted(environment, deployment, cluster)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ClustersApi->getTemplateRedacted: %s\n" % e)

Parameters

Path parameters

Name	Description
environment*	String Required
deployment*	String Required
cluster*	String Required

Responses

Status: 200 - OK

Schema

Status: 404 - Entity not found

list

List all clusters

/api/v8/environments/{environment}/deployments/{deployment}/clusters

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Authorization: Basic [[basicHash]]" "https://localhost/api/v8/environments/{environment}/deployments/{deployment}/clusters"

import com.cloudera.director.client.common.*;
import com.cloudera.director.client.common.auth.*;
import com.cloudera.director.client.common.model.*;
import com.cloudera.director.client.common.api.ClustersApi;

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

public class ClustersApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        ClustersApi apiInstance = new ClustersApi();
        String environment = environment_example; // String | 
        String deployment = deployment_example; // String | 
        try {
            array['String'] result = apiInstance.list(environment, deployment);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ClustersApi#list");
            e.printStackTrace();
        }
    }
}

import com.cloudera.director.client.common.api.ClustersApi;

public class ClustersApiExample {

    public static void main(String[] args) {
        ClustersApi apiInstance = new ClustersApi();
        String environment = environment_example; // String | 
        String deployment = deployment_example; // String | 
        try {
            array['String'] result = apiInstance.list(environment, deployment);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ClustersApi#list");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *environment = environment_example; // 
String *deployment = deployment_example; // 

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

// List all clusters
[apiInstance listWith:environment
    deployment:deployment
              completionHandler: ^(array['String'] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaAltusDirectorApi = require('cloudera_altus_director_api');
var defaultClient = ClouderaAltusDirectorApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new ClouderaAltusDirectorApi.ClustersApi()

var environment = environment_example; // {String} 

var deployment = deployment_example; // {String} 


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

using System;
using System.Diagnostics;
using cloudera.director.Api;
using cloudera.director.Client;
using cloudera.director.Model;

namespace Example
{
    public class listExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ClustersApi();
            var environment = environment_example;  // String | 
            var deployment = deployment_example;  // String | 

            try
            {
                // List all clusters
                array['String'] result = apiInstance.list(environment, deployment);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ClustersApi.list: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ClustersApi();
$environment = environment_example; // String | 
$deployment = deployment_example; // String | 

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

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ClustersApi->new();
my $environment = environment_example; # String | 
my $deployment = deployment_example; # String | 

eval { 
    my $result = $api_instance->list(environment => $environment, deployment => $deployment);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ClustersApi->list: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ClustersApi()
environment = environment_example # String | 
deployment = deployment_example # String | 

try: 
    # List all clusters
    api_response = api_instance.list(environment, deployment)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ClustersApi->list: %s\n" % e)

Parameters

Path parameters

Name	Description
environment*	String Required
deployment*	String Required

Responses

Status: 200 - OK

Schema

Status: 404 - Entity not found

update

Update an existing cluster

/api/v8/environments/{environment}/deployments/{deployment}/clusters/{cluster}

Usage and SDK Samples

curl -X PUT -H "Accept: application/json" -H "Authorization: Basic [[basicHash]]" "https://localhost/api/v8/environments/{environment}/deployments/{deployment}/clusters/{cluster}"

import com.cloudera.director.client.common.*;
import com.cloudera.director.client.common.auth.*;
import com.cloudera.director.client.common.model.*;
import com.cloudera.director.client.common.api.ClustersApi;

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

public class ClustersApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        ClustersApi apiInstance = new ClustersApi();
        String environment = environment_example; // String | 
        String deployment = deployment_example; // String | 
        String cluster = cluster_example; // String | 
        ClusterTemplate desired = ; // ClusterTemplate | 
        try {
            apiInstance.update(environment, deployment, cluster, desired);
        } catch (ApiException e) {
            System.err.println("Exception when calling ClustersApi#update");
            e.printStackTrace();
        }
    }
}

import com.cloudera.director.client.common.api.ClustersApi;

public class ClustersApiExample {

    public static void main(String[] args) {
        ClustersApi apiInstance = new ClustersApi();
        String environment = environment_example; // String | 
        String deployment = deployment_example; // String | 
        String cluster = cluster_example; // String | 
        ClusterTemplate desired = ; // ClusterTemplate | 
        try {
            apiInstance.update(environment, deployment, cluster, desired);
        } catch (ApiException e) {
            System.err.println("Exception when calling ClustersApi#update");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *environment = environment_example; // 
String *deployment = deployment_example; // 
String *cluster = cluster_example; // 
ClusterTemplate *desired = ; // 

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

// Update an existing cluster
[apiInstance updateWith:environment
    deployment:deployment
    cluster:cluster
    desired:desired
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaAltusDirectorApi = require('cloudera_altus_director_api');
var defaultClient = ClouderaAltusDirectorApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new ClouderaAltusDirectorApi.ClustersApi()

var environment = environment_example; // {String} 

var deployment = deployment_example; // {String} 

var cluster = cluster_example; // {String} 

var desired = ; // {ClusterTemplate} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.update(environment, deployment, cluster, desired, callback);

using System;
using System.Diagnostics;
using cloudera.director.Api;
using cloudera.director.Client;
using cloudera.director.Model;

namespace Example
{
    public class updateExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ClustersApi();
            var environment = environment_example;  // String | 
            var deployment = deployment_example;  // String | 
            var cluster = cluster_example;  // String | 
            var desired = new ClusterTemplate(); // ClusterTemplate | 

            try
            {
                // Update an existing cluster
                apiInstance.update(environment, deployment, cluster, desired);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ClustersApi.update: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ClustersApi();
$environment = environment_example; // String | 
$deployment = deployment_example; // String | 
$cluster = cluster_example; // String | 
$desired = ; // ClusterTemplate | 

try {
    $api_instance->update($environment, $deployment, $cluster, $desired);
} catch (Exception $e) {
    echo 'Exception when calling ClustersApi->update: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ClustersApi->new();
my $environment = environment_example; # String | 
my $deployment = deployment_example; # String | 
my $cluster = cluster_example; # String | 
my $desired = WWW::SwaggerClient::Object::ClusterTemplate->new(); # ClusterTemplate | 

eval { 
    $api_instance->update(environment => $environment, deployment => $deployment, cluster => $cluster, desired => $desired);
};
if ($@) {
    warn "Exception when calling ClustersApi->update: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ClustersApi()
environment = environment_example # String | 
deployment = deployment_example # String | 
cluster = cluster_example # String | 
desired =  # ClusterTemplate | 

try: 
    # Update an existing cluster
    api_instance.update(environment, deployment, cluster, desired)
except ApiException as e:
    print("Exception when calling ClustersApi->update: %s\n" % e)

Parameters

Path parameters

Name	Description
environment*	String Required
deployment*	String Required
cluster*	String Required

Body parameters

Name	Description
desired *

Responses

Status: 202 - Cluster update accepted

Status: 400 - Cluster update not supported

Status: 404 - Not found

Status: 409 - Cluster is in a non-updatable state

DatabaseServers

create

Create a new external database server

/api/v8/environments/{environment}/databaseServers

Usage and SDK Samples

curl -X POST -H "Accept: application/json" -H "Authorization: Basic [[basicHash]]" "https://localhost/api/v8/environments/{environment}/databaseServers"

import com.cloudera.director.client.common.*;
import com.cloudera.director.client.common.auth.*;
import com.cloudera.director.client.common.model.*;
import com.cloudera.director.client.common.api.DatabaseServersApi;

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

public class DatabaseServersApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        DatabaseServersApi apiInstance = new DatabaseServersApi();
        String environment = environment_example; // String | 
        ExternalDatabaseServerTemplate externalDatabaseServerTemplate = ; // ExternalDatabaseServerTemplate | 
        try {
            apiInstance.create(environment, externalDatabaseServerTemplate);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatabaseServersApi#create");
            e.printStackTrace();
        }
    }
}

import com.cloudera.director.client.common.api.DatabaseServersApi;

public class DatabaseServersApiExample {

    public static void main(String[] args) {
        DatabaseServersApi apiInstance = new DatabaseServersApi();
        String environment = environment_example; // String | 
        ExternalDatabaseServerTemplate externalDatabaseServerTemplate = ; // ExternalDatabaseServerTemplate | 
        try {
            apiInstance.create(environment, externalDatabaseServerTemplate);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatabaseServersApi#create");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *environment = environment_example; // 
ExternalDatabaseServerTemplate *externalDatabaseServerTemplate = ; // 

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

// Create a new external database server
[apiInstance createWith:environment
    externalDatabaseServerTemplate:externalDatabaseServerTemplate
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaAltusDirectorApi = require('cloudera_altus_director_api');
var defaultClient = ClouderaAltusDirectorApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new ClouderaAltusDirectorApi.DatabaseServersApi()

var environment = environment_example; // {String} 

var externalDatabaseServerTemplate = ; // {ExternalDatabaseServerTemplate} 


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

using System;
using System.Diagnostics;
using cloudera.director.Api;
using cloudera.director.Client;
using cloudera.director.Model;

namespace Example
{
    public class createExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DatabaseServersApi();
            var environment = environment_example;  // String | 
            var externalDatabaseServerTemplate = new ExternalDatabaseServerTemplate(); // ExternalDatabaseServerTemplate | 

            try
            {
                // Create a new external database server
                apiInstance.create(environment, externalDatabaseServerTemplate);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DatabaseServersApi.create: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DatabaseServersApi();
$environment = environment_example; // String | 
$externalDatabaseServerTemplate = ; // ExternalDatabaseServerTemplate | 

try {
    $api_instance->create($environment, $externalDatabaseServerTemplate);
} catch (Exception $e) {
    echo 'Exception when calling DatabaseServersApi->create: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DatabaseServersApi->new();
my $environment = environment_example; # String | 
my $externalDatabaseServerTemplate = WWW::SwaggerClient::Object::ExternalDatabaseServerTemplate->new(); # ExternalDatabaseServerTemplate | 

eval { 
    $api_instance->create(environment => $environment, externalDatabaseServerTemplate => $externalDatabaseServerTemplate);
};
if ($@) {
    warn "Exception when calling DatabaseServersApi->create: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DatabaseServersApi()
environment = environment_example # String | 
externalDatabaseServerTemplate =  # ExternalDatabaseServerTemplate | 

try: 
    # Create a new external database server
    api_instance.create(environment, externalDatabaseServerTemplate)
except ApiException as e:
    print("Exception when calling DatabaseServersApi->create: %s\n" % e)

Parameters

Path parameters

Name	Description
environment*	String Required

Body parameters

Name	Description
externalDatabaseServerTemplate *

Responses

Status: 201 - External database server template accepted

Status: 302 - External database server already exists

Status: 400 - Invalid external database server template

delete

Delete an external database server by name

/api/v8/environments/{environment}/databaseServers/{externalDatabaseServer}

Usage and SDK Samples

curl -X DELETE -H "Accept: application/json" -H "Authorization: Basic [[basicHash]]" "https://localhost/api/v8/environments/{environment}/databaseServers/{externalDatabaseServer}"

import com.cloudera.director.client.common.*;
import com.cloudera.director.client.common.auth.*;
import com.cloudera.director.client.common.model.*;
import com.cloudera.director.client.common.api.DatabaseServersApi;

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

public class DatabaseServersApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        DatabaseServersApi apiInstance = new DatabaseServersApi();
        String environment = environment_example; // String | 
        String externalDatabaseServer = externalDatabaseServer_example; // String | 
        try {
            apiInstance.delete(environment, externalDatabaseServer);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatabaseServersApi#delete");
            e.printStackTrace();
        }
    }
}

import com.cloudera.director.client.common.api.DatabaseServersApi;

public class DatabaseServersApiExample {

    public static void main(String[] args) {
        DatabaseServersApi apiInstance = new DatabaseServersApi();
        String environment = environment_example; // String | 
        String externalDatabaseServer = externalDatabaseServer_example; // String | 
        try {
            apiInstance.delete(environment, externalDatabaseServer);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatabaseServersApi#delete");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *environment = environment_example; // 
String *externalDatabaseServer = externalDatabaseServer_example; // 

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

// Delete an external database server by name
[apiInstance deleteWith:environment
    externalDatabaseServer:externalDatabaseServer
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaAltusDirectorApi = require('cloudera_altus_director_api');
var defaultClient = ClouderaAltusDirectorApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new ClouderaAltusDirectorApi.DatabaseServersApi()

var environment = environment_example; // {String} 

var externalDatabaseServer = externalDatabaseServer_example; // {String} 


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

using System;
using System.Diagnostics;
using cloudera.director.Api;
using cloudera.director.Client;
using cloudera.director.Model;

namespace Example
{
    public class deleteExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DatabaseServersApi();
            var environment = environment_example;  // String | 
            var externalDatabaseServer = externalDatabaseServer_example;  // String | 

            try
            {
                // Delete an external database server by name
                apiInstance.delete(environment, externalDatabaseServer);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DatabaseServersApi.delete: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DatabaseServersApi();
$environment = environment_example; // String | 
$externalDatabaseServer = externalDatabaseServer_example; // String | 

try {
    $api_instance->delete($environment, $externalDatabaseServer);
} catch (Exception $e) {
    echo 'Exception when calling DatabaseServersApi->delete: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DatabaseServersApi->new();
my $environment = environment_example; # String | 
my $externalDatabaseServer = externalDatabaseServer_example; # String | 

eval { 
    $api_instance->delete(environment => $environment, externalDatabaseServer => $externalDatabaseServer);
};
if ($@) {
    warn "Exception when calling DatabaseServersApi->delete: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DatabaseServersApi()
environment = environment_example # String | 
externalDatabaseServer = externalDatabaseServer_example # String | 

try: 
    # Delete an external database server by name
    api_instance.delete(environment, externalDatabaseServer)
except ApiException as e:
    print("Exception when calling DatabaseServersApi->delete: %s\n" % e)

Parameters

Path parameters

Name	Description
environment*	String Required
externalDatabaseServer*	String Required

Responses

Status: 204 - Delete request accepted

Status: 404 - Entity not found

getDatabaseServerUsage

Get an external database server usage by name

/api/v8/environments/{environment}/databaseServers/{externalDatabaseServer}/usage

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Authorization: Basic [[basicHash]]" "https://localhost/api/v8/environments/{environment}/databaseServers/{externalDatabaseServer}/usage"

import com.cloudera.director.client.common.*;
import com.cloudera.director.client.common.auth.*;
import com.cloudera.director.client.common.model.*;
import com.cloudera.director.client.common.api.DatabaseServersApi;

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

public class DatabaseServersApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        DatabaseServersApi apiInstance = new DatabaseServersApi();
        String environment = environment_example; // String | 
        String externalDatabaseServer = externalDatabaseServer_example; // String | 
        try {
            ExternalDatabaseServerUsage result = apiInstance.getDatabaseServerUsage(environment, externalDatabaseServer);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatabaseServersApi#getDatabaseServerUsage");
            e.printStackTrace();
        }
    }
}

import com.cloudera.director.client.common.api.DatabaseServersApi;

public class DatabaseServersApiExample {

    public static void main(String[] args) {
        DatabaseServersApi apiInstance = new DatabaseServersApi();
        String environment = environment_example; // String | 
        String externalDatabaseServer = externalDatabaseServer_example; // String | 
        try {
            ExternalDatabaseServerUsage result = apiInstance.getDatabaseServerUsage(environment, externalDatabaseServer);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatabaseServersApi#getDatabaseServerUsage");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *environment = environment_example; // 
String *externalDatabaseServer = externalDatabaseServer_example; // 

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

// Get an external database server usage by name
[apiInstance getDatabaseServerUsageWith:environment
    externalDatabaseServer:externalDatabaseServer
              completionHandler: ^(ExternalDatabaseServerUsage output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaAltusDirectorApi = require('cloudera_altus_director_api');
var defaultClient = ClouderaAltusDirectorApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new ClouderaAltusDirectorApi.DatabaseServersApi()

var environment = environment_example; // {String} 

var externalDatabaseServer = externalDatabaseServer_example; // {String} 


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

using System;
using System.Diagnostics;
using cloudera.director.Api;
using cloudera.director.Client;
using cloudera.director.Model;

namespace Example
{
    public class getDatabaseServerUsageExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DatabaseServersApi();
            var environment = environment_example;  // String | 
            var externalDatabaseServer = externalDatabaseServer_example;  // String | 

            try
            {
                // Get an external database server usage by name
                ExternalDatabaseServerUsage result = apiInstance.getDatabaseServerUsage(environment, externalDatabaseServer);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DatabaseServersApi.getDatabaseServerUsage: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DatabaseServersApi();
$environment = environment_example; // String | 
$externalDatabaseServer = externalDatabaseServer_example; // String | 

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

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DatabaseServersApi->new();
my $environment = environment_example; # String | 
my $externalDatabaseServer = externalDatabaseServer_example; # String | 

eval { 
    my $result = $api_instance->getDatabaseServerUsage(environment => $environment, externalDatabaseServer => $externalDatabaseServer);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DatabaseServersApi->getDatabaseServerUsage: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DatabaseServersApi()
environment = environment_example # String | 
externalDatabaseServer = externalDatabaseServer_example # String | 

try: 
    # Get an external database server usage by name
    api_response = api_instance.get_database_server_usage(environment, externalDatabaseServer)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DatabaseServersApi->getDatabaseServerUsage: %s\n" % e)

Parameters

Path parameters

Name	Description
environment*	String Required
externalDatabaseServer*	String Required

Responses

Status: 200 - OK

Schema

Status: 404 - Entity not found

getRedacted

Get an external database server by name

/api/v8/environments/{environment}/databaseServers/{externalDatabaseServer}

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Authorization: Basic [[basicHash]]" "https://localhost/api/v8/environments/{environment}/databaseServers/{externalDatabaseServer}"

import com.cloudera.director.client.common.*;
import com.cloudera.director.client.common.auth.*;
import com.cloudera.director.client.common.model.*;
import com.cloudera.director.client.common.api.DatabaseServersApi;

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

public class DatabaseServersApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        DatabaseServersApi apiInstance = new DatabaseServersApi();
        String environment = environment_example; // String | 
        String externalDatabaseServer = externalDatabaseServer_example; // String | 
        try {
            ExternalDatabaseServer result = apiInstance.getRedacted(environment, externalDatabaseServer);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatabaseServersApi#getRedacted");
            e.printStackTrace();
        }
    }
}

import com.cloudera.director.client.common.api.DatabaseServersApi;

public class DatabaseServersApiExample {

    public static void main(String[] args) {
        DatabaseServersApi apiInstance = new DatabaseServersApi();
        String environment = environment_example; // String | 
        String externalDatabaseServer = externalDatabaseServer_example; // String | 
        try {
            ExternalDatabaseServer result = apiInstance.getRedacted(environment, externalDatabaseServer);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatabaseServersApi#getRedacted");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *environment = environment_example; // 
String *externalDatabaseServer = externalDatabaseServer_example; // 

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

// Get an external database server by name
[apiInstance getRedactedWith:environment
    externalDatabaseServer:externalDatabaseServer
              completionHandler: ^(ExternalDatabaseServer output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaAltusDirectorApi = require('cloudera_altus_director_api');
var defaultClient = ClouderaAltusDirectorApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new ClouderaAltusDirectorApi.DatabaseServersApi()

var environment = environment_example; // {String} 

var externalDatabaseServer = externalDatabaseServer_example; // {String} 


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

using System;
using System.Diagnostics;
using cloudera.director.Api;
using cloudera.director.Client;
using cloudera.director.Model;

namespace Example
{
    public class getRedactedExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DatabaseServersApi();
            var environment = environment_example;  // String | 
            var externalDatabaseServer = externalDatabaseServer_example;  // String | 

            try
            {
                // Get an external database server by name
                ExternalDatabaseServer result = apiInstance.getRedacted(environment, externalDatabaseServer);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DatabaseServersApi.getRedacted: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DatabaseServersApi();
$environment = environment_example; // String | 
$externalDatabaseServer = externalDatabaseServer_example; // String | 

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

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DatabaseServersApi->new();
my $environment = environment_example; # String | 
my $externalDatabaseServer = externalDatabaseServer_example; # String | 

eval { 
    my $result = $api_instance->getRedacted(environment => $environment, externalDatabaseServer => $externalDatabaseServer);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DatabaseServersApi->getRedacted: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DatabaseServersApi()
environment = environment_example # String | 
externalDatabaseServer = externalDatabaseServer_example # String | 

try: 
    # Get an external database server by name
    api_response = api_instance.get_redacted(environment, externalDatabaseServer)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DatabaseServersApi->getRedacted: %s\n" % e)

Parameters

Path parameters

Name	Description
environment*	String Required
externalDatabaseServer*	String Required

Responses

Status: 200 - OK

Schema

Status: 204 - External database server is in transition or failed stage

Status: 404 - Entity not found

getStatus

Get an external database server status by name

/api/v8/environments/{environment}/databaseServers/{externalDatabaseServer}/status

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Authorization: Basic [[basicHash]]" "https://localhost/api/v8/environments/{environment}/databaseServers/{externalDatabaseServer}/status"

import com.cloudera.director.client.common.*;
import com.cloudera.director.client.common.auth.*;
import com.cloudera.director.client.common.model.*;
import com.cloudera.director.client.common.api.DatabaseServersApi;

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

public class DatabaseServersApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        DatabaseServersApi apiInstance = new DatabaseServersApi();
        String environment = environment_example; // String | 
        String externalDatabaseServer = externalDatabaseServer_example; // String | 
        try {
            Status result = apiInstance.getStatus(environment, externalDatabaseServer);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatabaseServersApi#getStatus");
            e.printStackTrace();
        }
    }
}

import com.cloudera.director.client.common.api.DatabaseServersApi;

public class DatabaseServersApiExample {

    public static void main(String[] args) {
        DatabaseServersApi apiInstance = new DatabaseServersApi();
        String environment = environment_example; // String | 
        String externalDatabaseServer = externalDatabaseServer_example; // String | 
        try {
            Status result = apiInstance.getStatus(environment, externalDatabaseServer);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatabaseServersApi#getStatus");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *environment = environment_example; // 
String *externalDatabaseServer = externalDatabaseServer_example; // 

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

// Get an external database server status by name
[apiInstance getStatusWith:environment
    externalDatabaseServer:externalDatabaseServer
              completionHandler: ^(Status output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaAltusDirectorApi = require('cloudera_altus_director_api');
var defaultClient = ClouderaAltusDirectorApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new ClouderaAltusDirectorApi.DatabaseServersApi()

var environment = environment_example; // {String} 

var externalDatabaseServer = externalDatabaseServer_example; // {String} 


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

using System;
using System.Diagnostics;
using cloudera.director.Api;
using cloudera.director.Client;
using cloudera.director.Model;

namespace Example
{
    public class getStatusExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DatabaseServersApi();
            var environment = environment_example;  // String | 
            var externalDatabaseServer = externalDatabaseServer_example;  // String | 

            try
            {
                // Get an external database server status by name
                Status result = apiInstance.getStatus(environment, externalDatabaseServer);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DatabaseServersApi.getStatus: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DatabaseServersApi();
$environment = environment_example; // String | 
$externalDatabaseServer = externalDatabaseServer_example; // String | 

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

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DatabaseServersApi->new();
my $environment = environment_example; # String | 
my $externalDatabaseServer = externalDatabaseServer_example; # String | 

eval { 
    my $result = $api_instance->getStatus(environment => $environment, externalDatabaseServer => $externalDatabaseServer);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DatabaseServersApi->getStatus: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DatabaseServersApi()
environment = environment_example # String | 
externalDatabaseServer = externalDatabaseServer_example # String | 

try: 
    # Get an external database server status by name
    api_response = api_instance.get_status(environment, externalDatabaseServer)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DatabaseServersApi->getStatus: %s\n" % e)

Parameters

Path parameters

Name	Description
environment*	String Required
externalDatabaseServer*	String Required

Responses

Status: 200 - OK

Schema

Status: 404 - Entity not found

getTemplateRedacted

Get an external database server template by name

/api/v8/environments/{environment}/databaseServers/{externalDatabaseServer}/template

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Authorization: Basic [[basicHash]]" "https://localhost/api/v8/environments/{environment}/databaseServers/{externalDatabaseServer}/template"

import com.cloudera.director.client.common.*;
import com.cloudera.director.client.common.auth.*;
import com.cloudera.director.client.common.model.*;
import com.cloudera.director.client.common.api.DatabaseServersApi;

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

public class DatabaseServersApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        DatabaseServersApi apiInstance = new DatabaseServersApi();
        String environment = environment_example; // String | 
        String externalDatabaseServer = externalDatabaseServer_example; // String | 
        try {
            ExternalDatabaseServerTemplate result = apiInstance.getTemplateRedacted(environment, externalDatabaseServer);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatabaseServersApi#getTemplateRedacted");
            e.printStackTrace();
        }
    }
}

import com.cloudera.director.client.common.api.DatabaseServersApi;

public class DatabaseServersApiExample {

    public static void main(String[] args) {
        DatabaseServersApi apiInstance = new DatabaseServersApi();
        String environment = environment_example; // String | 
        String externalDatabaseServer = externalDatabaseServer_example; // String | 
        try {
            ExternalDatabaseServerTemplate result = apiInstance.getTemplateRedacted(environment, externalDatabaseServer);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatabaseServersApi#getTemplateRedacted");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *environment = environment_example; // 
String *externalDatabaseServer = externalDatabaseServer_example; // 

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

// Get an external database server template by name
[apiInstance getTemplateRedactedWith:environment
    externalDatabaseServer:externalDatabaseServer
              completionHandler: ^(ExternalDatabaseServerTemplate output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaAltusDirectorApi = require('cloudera_altus_director_api');
var defaultClient = ClouderaAltusDirectorApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new ClouderaAltusDirectorApi.DatabaseServersApi()

var environment = environment_example; // {String} 

var externalDatabaseServer = externalDatabaseServer_example; // {String} 


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

using System;
using System.Diagnostics;
using cloudera.director.Api;
using cloudera.director.Client;
using cloudera.director.Model;

namespace Example
{
    public class getTemplateRedactedExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DatabaseServersApi();
            var environment = environment_example;  // String | 
            var externalDatabaseServer = externalDatabaseServer_example;  // String | 

            try
            {
                // Get an external database server template by name
                ExternalDatabaseServerTemplate result = apiInstance.getTemplateRedacted(environment, externalDatabaseServer);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DatabaseServersApi.getTemplateRedacted: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DatabaseServersApi();
$environment = environment_example; // String | 
$externalDatabaseServer = externalDatabaseServer_example; // String | 

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

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DatabaseServersApi->new();
my $environment = environment_example; # String | 
my $externalDatabaseServer = externalDatabaseServer_example; # String | 

eval { 
    my $result = $api_instance->getTemplateRedacted(environment => $environment, externalDatabaseServer => $externalDatabaseServer);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DatabaseServersApi->getTemplateRedacted: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DatabaseServersApi()
environment = environment_example # String | 
externalDatabaseServer = externalDatabaseServer_example # String | 

try: 
    # Get an external database server template by name
    api_response = api_instance.get_template_redacted(environment, externalDatabaseServer)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DatabaseServersApi->getTemplateRedacted: %s\n" % e)

Parameters

Path parameters

Name	Description
environment*	String Required
externalDatabaseServer*	String Required

Responses

Status: 200 - OK

Schema

Status: 404 - Entity not found

list

List all externalDatabaseServers

/api/v8/environments/{environment}/databaseServers

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Authorization: Basic [[basicHash]]" "https://localhost/api/v8/environments/{environment}/databaseServers"

import com.cloudera.director.client.common.*;
import com.cloudera.director.client.common.auth.*;
import com.cloudera.director.client.common.model.*;
import com.cloudera.director.client.common.api.DatabaseServersApi;

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

public class DatabaseServersApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        DatabaseServersApi apiInstance = new DatabaseServersApi();
        String environment = environment_example; // String | 
        try {
            array['String'] result = apiInstance.list(environment);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatabaseServersApi#list");
            e.printStackTrace();
        }
    }
}

import com.cloudera.director.client.common.api.DatabaseServersApi;

public class DatabaseServersApiExample {

    public static void main(String[] args) {
        DatabaseServersApi apiInstance = new DatabaseServersApi();
        String environment = environment_example; // String | 
        try {
            array['String'] result = apiInstance.list(environment);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatabaseServersApi#list");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *environment = environment_example; // 

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

// List all externalDatabaseServers
[apiInstance listWith:environment
              completionHandler: ^(array['String'] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaAltusDirectorApi = require('cloudera_altus_director_api');
var defaultClient = ClouderaAltusDirectorApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new ClouderaAltusDirectorApi.DatabaseServersApi()

var environment = environment_example; // {String} 


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

using System;
using System.Diagnostics;
using cloudera.director.Api;
using cloudera.director.Client;
using cloudera.director.Model;

namespace Example
{
    public class listExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DatabaseServersApi();
            var environment = environment_example;  // String | 

            try
            {
                // List all externalDatabaseServers
                array['String'] result = apiInstance.list(environment);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DatabaseServersApi.list: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DatabaseServersApi();
$environment = environment_example; // String | 

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

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DatabaseServersApi->new();
my $environment = environment_example; # String | 

eval { 
    my $result = $api_instance->list(environment => $environment);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DatabaseServersApi->list: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DatabaseServersApi()
environment = environment_example # String | 

try: 
    # List all externalDatabaseServers
    api_response = api_instance.list(environment)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DatabaseServersApi->list: %s\n" % e)

Parameters

Path parameters

Name	Description
environment*	String Required

Responses

Status: 200 - OK

Schema

Status: 404 - Environment not found

update

Update an existing external database server (unsupported)

/api/v8/environments/{environment}/databaseServers/{externalDatabaseServer}

Usage and SDK Samples

curl -X PUT -H "Accept: application/json" -H "Authorization: Basic [[basicHash]]" "https://localhost/api/v8/environments/{environment}/databaseServers/{externalDatabaseServer}"

import com.cloudera.director.client.common.*;
import com.cloudera.director.client.common.auth.*;
import com.cloudera.director.client.common.model.*;
import com.cloudera.director.client.common.api.DatabaseServersApi;

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

public class DatabaseServersApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        DatabaseServersApi apiInstance = new DatabaseServersApi();
        String environment = environment_example; // String | 
        String externalDatabaseServer = externalDatabaseServer_example; // String | 
        ExternalDatabaseServerTemplate updatedTemplate = ; // ExternalDatabaseServerTemplate | 
        try {
            apiInstance.update(environment, externalDatabaseServer, updatedTemplate);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatabaseServersApi#update");
            e.printStackTrace();
        }
    }
}

import com.cloudera.director.client.common.api.DatabaseServersApi;

public class DatabaseServersApiExample {

    public static void main(String[] args) {
        DatabaseServersApi apiInstance = new DatabaseServersApi();
        String environment = environment_example; // String | 
        String externalDatabaseServer = externalDatabaseServer_example; // String | 
        ExternalDatabaseServerTemplate updatedTemplate = ; // ExternalDatabaseServerTemplate | 
        try {
            apiInstance.update(environment, externalDatabaseServer, updatedTemplate);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatabaseServersApi#update");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *environment = environment_example; // 
String *externalDatabaseServer = externalDatabaseServer_example; // 
ExternalDatabaseServerTemplate *updatedTemplate = ; // 

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

// Update an existing external database server (unsupported)
[apiInstance updateWith:environment
    externalDatabaseServer:externalDatabaseServer
    updatedTemplate:updatedTemplate
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaAltusDirectorApi = require('cloudera_altus_director_api');
var defaultClient = ClouderaAltusDirectorApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new ClouderaAltusDirectorApi.DatabaseServersApi()

var environment = environment_example; // {String} 

var externalDatabaseServer = externalDatabaseServer_example; // {String} 

var updatedTemplate = ; // {ExternalDatabaseServerTemplate} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.update(environment, externalDatabaseServer, updatedTemplate, callback);

using System;
using System.Diagnostics;
using cloudera.director.Api;
using cloudera.director.Client;
using cloudera.director.Model;

namespace Example
{
    public class updateExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DatabaseServersApi();
            var environment = environment_example;  // String | 
            var externalDatabaseServer = externalDatabaseServer_example;  // String | 
            var updatedTemplate = new ExternalDatabaseServerTemplate(); // ExternalDatabaseServerTemplate | 

            try
            {
                // Update an existing external database server (unsupported)
                apiInstance.update(environment, externalDatabaseServer, updatedTemplate);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DatabaseServersApi.update: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DatabaseServersApi();
$environment = environment_example; // String | 
$externalDatabaseServer = externalDatabaseServer_example; // String | 
$updatedTemplate = ; // ExternalDatabaseServerTemplate | 

try {
    $api_instance->update($environment, $externalDatabaseServer, $updatedTemplate);
} catch (Exception $e) {
    echo 'Exception when calling DatabaseServersApi->update: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DatabaseServersApi->new();
my $environment = environment_example; # String | 
my $externalDatabaseServer = externalDatabaseServer_example; # String | 
my $updatedTemplate = WWW::SwaggerClient::Object::ExternalDatabaseServerTemplate->new(); # ExternalDatabaseServerTemplate | 

eval { 
    $api_instance->update(environment => $environment, externalDatabaseServer => $externalDatabaseServer, updatedTemplate => $updatedTemplate);
};
if ($@) {
    warn "Exception when calling DatabaseServersApi->update: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DatabaseServersApi()
environment = environment_example # String | 
externalDatabaseServer = externalDatabaseServer_example # String | 
updatedTemplate =  # ExternalDatabaseServerTemplate | 

try: 
    # Update an existing external database server (unsupported)
    api_instance.update(environment, externalDatabaseServer, updatedTemplate)
except ApiException as e:
    print("Exception when calling DatabaseServersApi->update: %s\n" % e)

Parameters

Path parameters

Name	Description
environment*	String Required
externalDatabaseServer*	String Required

Body parameters

Name	Description
updatedTemplate *

Responses

Status: 400 - External database server update not supported

Deployments

collectDiagnosticData

Collects diagnostic data

/api/v8/environments/{environment}/deployments/{deployment}/diagnosticData

Usage and SDK Samples

curl -X POST -H "Accept: application/json" -H "Authorization: Basic [[basicHash]]" "https://localhost/api/v8/environments/{environment}/deployments/{deployment}/diagnosticData"

import com.cloudera.director.client.common.*;
import com.cloudera.director.client.common.auth.*;
import com.cloudera.director.client.common.model.*;
import com.cloudera.director.client.common.api.DeploymentsApi;

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

public class DeploymentsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        DeploymentsApi apiInstance = new DeploymentsApi();
        String environment = environment_example; // String | 
        String deployment = deployment_example; // String | 
        try {
            apiInstance.collectDiagnosticData(environment, deployment);
        } catch (ApiException e) {
            System.err.println("Exception when calling DeploymentsApi#collectDiagnosticData");
            e.printStackTrace();
        }
    }
}

import com.cloudera.director.client.common.api.DeploymentsApi;

public class DeploymentsApiExample {

    public static void main(String[] args) {
        DeploymentsApi apiInstance = new DeploymentsApi();
        String environment = environment_example; // String | 
        String deployment = deployment_example; // String | 
        try {
            apiInstance.collectDiagnosticData(environment, deployment);
        } catch (ApiException e) {
            System.err.println("Exception when calling DeploymentsApi#collectDiagnosticData");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *environment = environment_example; // 
String *deployment = deployment_example; // 

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

// Collects diagnostic data
[apiInstance collectDiagnosticDataWith:environment
    deployment:deployment
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaAltusDirectorApi = require('cloudera_altus_director_api');
var defaultClient = ClouderaAltusDirectorApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new ClouderaAltusDirectorApi.DeploymentsApi()

var environment = environment_example; // {String} 

var deployment = deployment_example; // {String} 


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

using System;
using System.Diagnostics;
using cloudera.director.Api;
using cloudera.director.Client;
using cloudera.director.Model;

namespace Example
{
    public class collectDiagnosticDataExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DeploymentsApi();
            var environment = environment_example;  // String | 
            var deployment = deployment_example;  // String | 

            try
            {
                // Collects diagnostic data
                apiInstance.collectDiagnosticData(environment, deployment);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DeploymentsApi.collectDiagnosticData: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DeploymentsApi();
$environment = environment_example; // String | 
$deployment = deployment_example; // String | 

try {
    $api_instance->collectDiagnosticData($environment, $deployment);
} catch (Exception $e) {
    echo 'Exception when calling DeploymentsApi->collectDiagnosticData: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DeploymentsApi->new();
my $environment = environment_example; # String | 
my $deployment = deployment_example; # String | 

eval { 
    $api_instance->collectDiagnosticData(environment => $environment, deployment => $deployment);
};
if ($@) {
    warn "Exception when calling DeploymentsApi->collectDiagnosticData: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DeploymentsApi()
environment = environment_example # String | 
deployment = deployment_example # String | 

try: 
    # Collects diagnostic data
    api_instance.collect_diagnostic_data(environment, deployment)
except ApiException as e:
    print("Exception when calling DeploymentsApi->collectDiagnosticData: %s\n" % e)

Parameters

Path parameters

Name	Description
environment*	String Required
deployment*	String Required

Responses

Status: 202 - Accepted

Status: 404 - Entity not found

Status: 409 - Deployment is in transition

Status: 412 - Deployment is not available

create

Create a new deployment

/api/v8/environments/{environment}/deployments

Usage and SDK Samples

curl -X POST -H "Accept: application/json" -H "Authorization: Basic [[basicHash]]" "https://localhost/api/v8/environments/{environment}/deployments"

import com.cloudera.director.client.common.*;
import com.cloudera.director.client.common.auth.*;
import com.cloudera.director.client.common.model.*;
import com.cloudera.director.client.common.api.DeploymentsApi;

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

public class DeploymentsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        DeploymentsApi apiInstance = new DeploymentsApi();
        String environment = environment_example; // String | 
        DeploymentTemplate deploymentTemplate = ; // DeploymentTemplate | 
        try {
            apiInstance.create(environment, deploymentTemplate);
        } catch (ApiException e) {
            System.err.println("Exception when calling DeploymentsApi#create");
            e.printStackTrace();
        }
    }
}

import com.cloudera.director.client.common.api.DeploymentsApi;

public class DeploymentsApiExample {

    public static void main(String[] args) {
        DeploymentsApi apiInstance = new DeploymentsApi();
        String environment = environment_example; // String | 
        DeploymentTemplate deploymentTemplate = ; // DeploymentTemplate | 
        try {
            apiInstance.create(environment, deploymentTemplate);
        } catch (ApiException e) {
            System.err.println("Exception when calling DeploymentsApi#create");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *environment = environment_example; // 
DeploymentTemplate *deploymentTemplate = ; // 

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

// Create a new deployment
[apiInstance createWith:environment
    deploymentTemplate:deploymentTemplate
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaAltusDirectorApi = require('cloudera_altus_director_api');
var defaultClient = ClouderaAltusDirectorApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new ClouderaAltusDirectorApi.DeploymentsApi()

var environment = environment_example; // {String} 

var deploymentTemplate = ; // {DeploymentTemplate} 


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

using System;
using System.Diagnostics;
using cloudera.director.Api;
using cloudera.director.Client;
using cloudera.director.Model;

namespace Example
{
    public class createExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DeploymentsApi();
            var environment = environment_example;  // String | 
            var deploymentTemplate = new DeploymentTemplate(); // DeploymentTemplate | 

            try
            {
                // Create a new deployment
                apiInstance.create(environment, deploymentTemplate);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DeploymentsApi.create: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DeploymentsApi();
$environment = environment_example; // String | 
$deploymentTemplate = ; // DeploymentTemplate | 

try {
    $api_instance->create($environment, $deploymentTemplate);
} catch (Exception $e) {
    echo 'Exception when calling DeploymentsApi->create: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DeploymentsApi->new();
my $environment = environment_example; # String | 
my $deploymentTemplate = WWW::SwaggerClient::Object::DeploymentTemplate->new(); # DeploymentTemplate | 

eval { 
    $api_instance->create(environment => $environment, deploymentTemplate => $deploymentTemplate);
};
if ($@) {
    warn "Exception when calling DeploymentsApi->create: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DeploymentsApi()
environment = environment_example # String | 
deploymentTemplate =  # DeploymentTemplate | 

try: 
    # Create a new deployment
    api_instance.create(environment, deploymentTemplate)
except ApiException as e:
    print("Exception when calling DeploymentsApi->create: %s\n" % e)

Parameters

Path parameters

Name	Description
environment*	String Required

Body parameters

Name	Description
deploymentTemplate *

Responses

Status: 201 - Deployment template accepted

Status: 302 - Deployment already exists

Status: 400 - Invalid deployment template

delete

Delete a deployment by name

/api/v8/environments/{environment}/deployments/{deployment}

Usage and SDK Samples

curl -X DELETE -H "Accept: application/json" -H "Authorization: Basic [[basicHash]]" "https://localhost/api/v8/environments/{environment}/deployments/{deployment}"

import com.cloudera.director.client.common.*;
import com.cloudera.director.client.common.auth.*;
import com.cloudera.director.client.common.model.*;
import com.cloudera.director.client.common.api.DeploymentsApi;

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

public class DeploymentsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        DeploymentsApi apiInstance = new DeploymentsApi();
        String environment = environment_example; // String | 
        String deployment = deployment_example; // String | 
        try {
            apiInstance.delete(environment, deployment);
        } catch (ApiException e) {
            System.err.println("Exception when calling DeploymentsApi#delete");
            e.printStackTrace();
        }
    }
}

import com.cloudera.director.client.common.api.DeploymentsApi;

public class DeploymentsApiExample {

    public static void main(String[] args) {
        DeploymentsApi apiInstance = new DeploymentsApi();
        String environment = environment_example; // String | 
        String deployment = deployment_example; // String | 
        try {
            apiInstance.delete(environment, deployment);
        } catch (ApiException e) {
            System.err.println("Exception when calling DeploymentsApi#delete");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *environment = environment_example; // 
String *deployment = deployment_example; // 

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

// Delete a deployment by name
[apiInstance deleteWith:environment
    deployment:deployment
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaAltusDirectorApi = require('cloudera_altus_director_api');
var defaultClient = ClouderaAltusDirectorApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new ClouderaAltusDirectorApi.DeploymentsApi()

var environment = environment_example; // {String} 

var deployment = deployment_example; // {String} 


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

using System;
using System.Diagnostics;
using cloudera.director.Api;
using cloudera.director.Client;
using cloudera.director.Model;

namespace Example
{
    public class deleteExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DeploymentsApi();
            var environment = environment_example;  // String | 
            var deployment = deployment_example;  // String | 

            try
            {
                // Delete a deployment by name
                apiInstance.delete(environment, deployment);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DeploymentsApi.delete: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DeploymentsApi();
$environment = environment_example; // String | 
$deployment = deployment_example; // String | 

try {
    $api_instance->delete($environment, $deployment);
} catch (Exception $e) {
    echo 'Exception when calling DeploymentsApi->delete: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DeploymentsApi->new();
my $environment = environment_example; # String | 
my $deployment = deployment_example; # String | 

eval { 
    $api_instance->delete(environment => $environment, deployment => $deployment);
};
if ($@) {
    warn "Exception when calling DeploymentsApi->delete: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DeploymentsApi()
environment = environment_example # String | 
deployment = deployment_example # String | 

try: 
    # Delete a deployment by name
    api_instance.delete(environment, deployment)
except ApiException as e:
    print("Exception when calling DeploymentsApi->delete: %s\n" % e)

Parameters

Path parameters

Name	Description
environment*	String Required
deployment*	String Required

Responses

Status: 204 - Delete request accepted

Status: 404 - Entity not found

getRedacted

Get a deployment by name

/api/v8/environments/{environment}/deployments/{deployment}

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Authorization: Basic [[basicHash]]" "https://localhost/api/v8/environments/{environment}/deployments/{deployment}"

import com.cloudera.director.client.common.*;
import com.cloudera.director.client.common.auth.*;
import com.cloudera.director.client.common.model.*;
import com.cloudera.director.client.common.api.DeploymentsApi;

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

public class DeploymentsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        DeploymentsApi apiInstance = new DeploymentsApi();
        String environment = environment_example; // String | 
        String deployment = deployment_example; // String | 
        try {
            Deployment result = apiInstance.getRedacted(environment, deployment);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DeploymentsApi#getRedacted");
            e.printStackTrace();
        }
    }
}

import com.cloudera.director.client.common.api.DeploymentsApi;

public class DeploymentsApiExample {

    public static void main(String[] args) {
        DeploymentsApi apiInstance = new DeploymentsApi();
        String environment = environment_example; // String | 
        String deployment = deployment_example; // String | 
        try {
            Deployment result = apiInstance.getRedacted(environment, deployment);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DeploymentsApi#getRedacted");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *environment = environment_example; // 
String *deployment = deployment_example; // 

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

// Get a deployment by name
[apiInstance getRedactedWith:environment
    deployment:deployment
              completionHandler: ^(Deployment output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaAltusDirectorApi = require('cloudera_altus_director_api');
var defaultClient = ClouderaAltusDirectorApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new ClouderaAltusDirectorApi.DeploymentsApi()

var environment = environment_example; // {String} 

var deployment = deployment_example; // {String} 


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

using System;
using System.Diagnostics;
using cloudera.director.Api;
using cloudera.director.Client;
using cloudera.director.Model;

namespace Example
{
    public class getRedactedExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DeploymentsApi();
            var environment = environment_example;  // String | 
            var deployment = deployment_example;  // String | 

            try
            {
                // Get a deployment by name
                Deployment result = apiInstance.getRedacted(environment, deployment);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DeploymentsApi.getRedacted: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DeploymentsApi();
$environment = environment_example; // String | 
$deployment = deployment_example; // String | 

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

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DeploymentsApi->new();
my $environment = environment_example; # String | 
my $deployment = deployment_example; # String | 

eval { 
    my $result = $api_instance->getRedacted(environment => $environment, deployment => $deployment);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DeploymentsApi->getRedacted: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DeploymentsApi()
environment = environment_example # String | 
deployment = deployment_example # String | 

try: 
    # Get a deployment by name
    api_response = api_instance.get_redacted(environment, deployment)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DeploymentsApi->getRedacted: %s\n" % e)

Parameters

Path parameters

Name	Description
environment*	String Required
deployment*	String Required

Responses

Status: 200 - OK

Schema

Status: 204 - Deployment is in transition or failed stage

Status: 404 - Entity not found

getStatus

Get a deployment status by name

/api/v8/environments/{environment}/deployments/{deployment}/status

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Authorization: Basic [[basicHash]]" "https://localhost/api/v8/environments/{environment}/deployments/{deployment}/status"

import com.cloudera.director.client.common.*;
import com.cloudera.director.client.common.auth.*;
import com.cloudera.director.client.common.model.*;
import com.cloudera.director.client.common.api.DeploymentsApi;

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

public class DeploymentsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        DeploymentsApi apiInstance = new DeploymentsApi();
        String environment = environment_example; // String | 
        String deployment = deployment_example; // String | 
        try {
            Status result = apiInstance.getStatus(environment, deployment);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DeploymentsApi#getStatus");
            e.printStackTrace();
        }
    }
}

import com.cloudera.director.client.common.api.DeploymentsApi;

public class DeploymentsApiExample {

    public static void main(String[] args) {
        DeploymentsApi apiInstance = new DeploymentsApi();
        String environment = environment_example; // String | 
        String deployment = deployment_example; // String | 
        try {
            Status result = apiInstance.getStatus(environment, deployment);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DeploymentsApi#getStatus");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *environment = environment_example; // 
String *deployment = deployment_example; // 

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

// Get a deployment status by name
[apiInstance getStatusWith:environment
    deployment:deployment
              completionHandler: ^(Status output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaAltusDirectorApi = require('cloudera_altus_director_api');
var defaultClient = ClouderaAltusDirectorApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new ClouderaAltusDirectorApi.DeploymentsApi()

var environment = environment_example; // {String} 

var deployment = deployment_example; // {String} 


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

using System;
using System.Diagnostics;
using cloudera.director.Api;
using cloudera.director.Client;
using cloudera.director.Model;

namespace Example
{
    public class getStatusExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DeploymentsApi();
            var environment = environment_example;  // String | 
            var deployment = deployment_example;  // String | 

            try
            {
                // Get a deployment status by name
                Status result = apiInstance.getStatus(environment, deployment);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DeploymentsApi.getStatus: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DeploymentsApi();
$environment = environment_example; // String | 
$deployment = deployment_example; // String | 

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

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DeploymentsApi->new();
my $environment = environment_example; # String | 
my $deployment = deployment_example; # String | 

eval { 
    my $result = $api_instance->getStatus(environment => $environment, deployment => $deployment);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DeploymentsApi->getStatus: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DeploymentsApi()
environment = environment_example # String | 
deployment = deployment_example # String | 

try: 
    # Get a deployment status by name
    api_response = api_instance.get_status(environment, deployment)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DeploymentsApi->getStatus: %s\n" % e)

Parameters

Path parameters

Name	Description
environment*	String Required
deployment*	String Required

Responses

Status: 200 - OK

Schema

Status: 404 - Entity not found

getTemplateRedacted

Get a deployment template by name

/api/v8/environments/{environment}/deployments/{deployment}/template

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Authorization: Basic [[basicHash]]" "https://localhost/api/v8/environments/{environment}/deployments/{deployment}/template"

import com.cloudera.director.client.common.*;
import com.cloudera.director.client.common.auth.*;
import com.cloudera.director.client.common.model.*;
import com.cloudera.director.client.common.api.DeploymentsApi;

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

public class DeploymentsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        DeploymentsApi apiInstance = new DeploymentsApi();
        String environment = environment_example; // String | 
        String deployment = deployment_example; // String | 
        try {
            DeploymentTemplate result = apiInstance.getTemplateRedacted(environment, deployment);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DeploymentsApi#getTemplateRedacted");
            e.printStackTrace();
        }
    }
}

import com.cloudera.director.client.common.api.DeploymentsApi;

public class DeploymentsApiExample {

    public static void main(String[] args) {
        DeploymentsApi apiInstance = new DeploymentsApi();
        String environment = environment_example; // String | 
        String deployment = deployment_example; // String | 
        try {
            DeploymentTemplate result = apiInstance.getTemplateRedacted(environment, deployment);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DeploymentsApi#getTemplateRedacted");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *environment = environment_example; // 
String *deployment = deployment_example; // 

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

// Get a deployment template by name
[apiInstance getTemplateRedactedWith:environment
    deployment:deployment
              completionHandler: ^(DeploymentTemplate output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaAltusDirectorApi = require('cloudera_altus_director_api');
var defaultClient = ClouderaAltusDirectorApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new ClouderaAltusDirectorApi.DeploymentsApi()

var environment = environment_example; // {String} 

var deployment = deployment_example; // {String} 


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

using System;
using System.Diagnostics;
using cloudera.director.Api;
using cloudera.director.Client;
using cloudera.director.Model;

namespace Example
{
    public class getTemplateRedactedExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DeploymentsApi();
            var environment = environment_example;  // String | 
            var deployment = deployment_example;  // String | 

            try
            {
                // Get a deployment template by name
                DeploymentTemplate result = apiInstance.getTemplateRedacted(environment, deployment);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DeploymentsApi.getTemplateRedacted: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DeploymentsApi();
$environment = environment_example; // String | 
$deployment = deployment_example; // String | 

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

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DeploymentsApi->new();
my $environment = environment_example; # String | 
my $deployment = deployment_example; # String | 

eval { 
    my $result = $api_instance->getTemplateRedacted(environment => $environment, deployment => $deployment);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DeploymentsApi->getTemplateRedacted: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DeploymentsApi()
environment = environment_example # String | 
deployment = deployment_example # String | 

try: 
    # Get a deployment template by name
    api_response = api_instance.get_template_redacted(environment, deployment)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DeploymentsApi->getTemplateRedacted: %s\n" % e)

Parameters

Path parameters

Name	Description
environment*	String Required
deployment*	String Required

Responses

Status: 200 - OK

Schema

Status: 404 - Entity not found

list

List all deployments

/api/v8/environments/{environment}/deployments

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Authorization: Basic [[basicHash]]" "https://localhost/api/v8/environments/{environment}/deployments"

import com.cloudera.director.client.common.*;
import com.cloudera.director.client.common.auth.*;
import com.cloudera.director.client.common.model.*;
import com.cloudera.director.client.common.api.DeploymentsApi;

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

public class DeploymentsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        DeploymentsApi apiInstance = new DeploymentsApi();
        String environment = environment_example; // String | 
        try {
            array['String'] result = apiInstance.list(environment);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DeploymentsApi#list");
            e.printStackTrace();
        }
    }
}

import com.cloudera.director.client.common.api.DeploymentsApi;

public class DeploymentsApiExample {

    public static void main(String[] args) {
        DeploymentsApi apiInstance = new DeploymentsApi();
        String environment = environment_example; // String | 
        try {
            array['String'] result = apiInstance.list(environment);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DeploymentsApi#list");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *environment = environment_example; // 

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

// List all deployments
[apiInstance listWith:environment
              completionHandler: ^(array['String'] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaAltusDirectorApi = require('cloudera_altus_director_api');
var defaultClient = ClouderaAltusDirectorApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new ClouderaAltusDirectorApi.DeploymentsApi()

var environment = environment_example; // {String} 


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

using System;
using System.Diagnostics;
using cloudera.director.Api;
using cloudera.director.Client;
using cloudera.director.Model;

namespace Example
{
    public class listExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DeploymentsApi();
            var environment = environment_example;  // String | 

            try
            {
                // List all deployments
                array['String'] result = apiInstance.list(environment);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DeploymentsApi.list: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DeploymentsApi();
$environment = environment_example; // String | 

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

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DeploymentsApi->new();
my $environment = environment_example; # String | 

eval { 
    my $result = $api_instance->list(environment => $environment);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DeploymentsApi->list: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DeploymentsApi()
environment = environment_example # String | 

try: 
    # List all deployments
    api_response = api_instance.list(environment)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DeploymentsApi->list: %s\n" % e)

Parameters

Path parameters

Name	Description
environment*	String Required

Responses

Status: 200 - OK

Schema

Status: 404 - Environment not found

update

Update an existing deployment template

/api/v8/environments/{environment}/deployments/{deployment}

Usage and SDK Samples

curl -X PUT -H "Accept: application/json" -H "Authorization: Basic [[basicHash]]" "https://localhost/api/v8/environments/{environment}/deployments/{deployment}"

import com.cloudera.director.client.common.*;
import com.cloudera.director.client.common.auth.*;
import com.cloudera.director.client.common.model.*;
import com.cloudera.director.client.common.api.DeploymentsApi;

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

public class DeploymentsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        DeploymentsApi apiInstance = new DeploymentsApi();
        String environment = environment_example; // String | 
        String deployment = deployment_example; // String | 
        DeploymentTemplate updatedTemplate = ; // DeploymentTemplate | 
        try {
            apiInstance.update(environment, deployment, updatedTemplate);
        } catch (ApiException e) {
            System.err.println("Exception when calling DeploymentsApi#update");
            e.printStackTrace();
        }
    }
}

import com.cloudera.director.client.common.api.DeploymentsApi;

public class DeploymentsApiExample {

    public static void main(String[] args) {
        DeploymentsApi apiInstance = new DeploymentsApi();
        String environment = environment_example; // String | 
        String deployment = deployment_example; // String | 
        DeploymentTemplate updatedTemplate = ; // DeploymentTemplate | 
        try {
            apiInstance.update(environment, deployment, updatedTemplate);
        } catch (ApiException e) {
            System.err.println("Exception when calling DeploymentsApi#update");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *environment = environment_example; // 
String *deployment = deployment_example; // 
DeploymentTemplate *updatedTemplate = ; // 

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

// Update an existing deployment template
[apiInstance updateWith:environment
    deployment:deployment
    updatedTemplate:updatedTemplate
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaAltusDirectorApi = require('cloudera_altus_director_api');
var defaultClient = ClouderaAltusDirectorApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new ClouderaAltusDirectorApi.DeploymentsApi()

var environment = environment_example; // {String} 

var deployment = deployment_example; // {String} 

var updatedTemplate = ; // {DeploymentTemplate} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.update(environment, deployment, updatedTemplate, callback);

using System;
using System.Diagnostics;
using cloudera.director.Api;
using cloudera.director.Client;
using cloudera.director.Model;

namespace Example
{
    public class updateExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DeploymentsApi();
            var environment = environment_example;  // String | 
            var deployment = deployment_example;  // String | 
            var updatedTemplate = new DeploymentTemplate(); // DeploymentTemplate | 

            try
            {
                // Update an existing deployment template
                apiInstance.update(environment, deployment, updatedTemplate);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DeploymentsApi.update: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DeploymentsApi();
$environment = environment_example; // String | 
$deployment = deployment_example; // String | 
$updatedTemplate = ; // DeploymentTemplate | 

try {
    $api_instance->update($environment, $deployment, $updatedTemplate);
} catch (Exception $e) {
    echo 'Exception when calling DeploymentsApi->update: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DeploymentsApi->new();
my $environment = environment_example; # String | 
my $deployment = deployment_example; # String | 
my $updatedTemplate = WWW::SwaggerClient::Object::DeploymentTemplate->new(); # DeploymentTemplate | 

eval { 
    $api_instance->update(environment => $environment, deployment => $deployment, updatedTemplate => $updatedTemplate);
};
if ($@) {
    warn "Exception when calling DeploymentsApi->update: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DeploymentsApi()
environment = environment_example # String | 
deployment = deployment_example # String | 
updatedTemplate =  # DeploymentTemplate | 

try: 
    # Update an existing deployment template
    api_instance.update(environment, deployment, updatedTemplate)
except ApiException as e:
    print("Exception when calling DeploymentsApi->update: %s\n" % e)

Parameters

Path parameters

Name	Description
environment*	String Required
deployment*	String Required

Body parameters

Name	Description
updatedTemplate *

Responses

Status: 400 - Deployment template update not supported

updateMeteringSetting

Update billing ID for an existing deployment

/api/v8/environments/{environment}/deployments/{deployment}/metering

Usage and SDK Samples

curl -X PUT -H "Accept: application/json" -H "Authorization: Basic [[basicHash]]" "https://localhost/api/v8/environments/{environment}/deployments/{deployment}/metering"

import com.cloudera.director.client.common.*;
import com.cloudera.director.client.common.auth.*;
import com.cloudera.director.client.common.model.*;
import com.cloudera.director.client.common.api.DeploymentsApi;

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

public class DeploymentsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        DeploymentsApi apiInstance = new DeploymentsApi();
        String environment = environment_example; // String | 
        String deployment = deployment_example; // String | 
        MeteringSetting meteringSetting = ; // MeteringSetting | 
        try {
            apiInstance.updateMeteringSetting(environment, deployment, meteringSetting);
        } catch (ApiException e) {
            System.err.println("Exception when calling DeploymentsApi#updateMeteringSetting");
            e.printStackTrace();
        }
    }
}

import com.cloudera.director.client.common.api.DeploymentsApi;

public class DeploymentsApiExample {

    public static void main(String[] args) {
        DeploymentsApi apiInstance = new DeploymentsApi();
        String environment = environment_example; // String | 
        String deployment = deployment_example; // String | 
        MeteringSetting meteringSetting = ; // MeteringSetting | 
        try {
            apiInstance.updateMeteringSetting(environment, deployment, meteringSetting);
        } catch (ApiException e) {
            System.err.println("Exception when calling DeploymentsApi#updateMeteringSetting");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *environment = environment_example; // 
String *deployment = deployment_example; // 
MeteringSetting *meteringSetting = ; // 

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

// Update billing ID for an existing deployment
[apiInstance updateMeteringSettingWith:environment
    deployment:deployment
    meteringSetting:meteringSetting
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaAltusDirectorApi = require('cloudera_altus_director_api');
var defaultClient = ClouderaAltusDirectorApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new ClouderaAltusDirectorApi.DeploymentsApi()

var environment = environment_example; // {String} 

var deployment = deployment_example; // {String} 

var meteringSetting = ; // {MeteringSetting} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.updateMeteringSetting(environment, deployment, meteringSetting, callback);

using System;
using System.Diagnostics;
using cloudera.director.Api;
using cloudera.director.Client;
using cloudera.director.Model;

namespace Example
{
    public class updateMeteringSettingExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DeploymentsApi();
            var environment = environment_example;  // String | 
            var deployment = deployment_example;  // String | 
            var meteringSetting = new MeteringSetting(); // MeteringSetting | 

            try
            {
                // Update billing ID for an existing deployment
                apiInstance.updateMeteringSetting(environment, deployment, meteringSetting);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DeploymentsApi.updateMeteringSetting: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DeploymentsApi();
$environment = environment_example; // String | 
$deployment = deployment_example; // String | 
$meteringSetting = ; // MeteringSetting | 

try {
    $api_instance->updateMeteringSetting($environment, $deployment, $meteringSetting);
} catch (Exception $e) {
    echo 'Exception when calling DeploymentsApi->updateMeteringSetting: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DeploymentsApi->new();
my $environment = environment_example; # String | 
my $deployment = deployment_example; # String | 
my $meteringSetting = WWW::SwaggerClient::Object::MeteringSetting->new(); # MeteringSetting | 

eval { 
    $api_instance->updateMeteringSetting(environment => $environment, deployment => $deployment, meteringSetting => $meteringSetting);
};
if ($@) {
    warn "Exception when calling DeploymentsApi->updateMeteringSetting: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DeploymentsApi()
environment = environment_example # String | 
deployment = deployment_example # String | 
meteringSetting =  # MeteringSetting | 

try: 
    # Update billing ID for an existing deployment
    api_instance.update_metering_setting(environment, deployment, meteringSetting)
except ApiException as e:
    print("Exception when calling DeploymentsApi->updateMeteringSetting: %s\n" % e)

Parameters

Path parameters

Name	Description
environment*	String Required
deployment*	String Required

Body parameters

Name	Description
meteringSetting *

Responses

Status: 400 - Update billing ID failed

Environments

create

Create a new environment

/api/v8/environments

Usage and SDK Samples

curl -X POST -H "Accept: application/json" -H "Authorization: Basic [[basicHash]]" "https://localhost/api/v8/environments"

import com.cloudera.director.client.common.*;
import com.cloudera.director.client.common.auth.*;
import com.cloudera.director.client.common.model.*;
import com.cloudera.director.client.common.api.EnvironmentsApi;

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

public class EnvironmentsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        EnvironmentsApi apiInstance = new EnvironmentsApi();
        Environment environment = ; // Environment | 
        try {
            apiInstance.create(environment);
        } catch (ApiException e) {
            System.err.println("Exception when calling EnvironmentsApi#create");
            e.printStackTrace();
        }
    }
}

import com.cloudera.director.client.common.api.EnvironmentsApi;

public class EnvironmentsApiExample {

    public static void main(String[] args) {
        EnvironmentsApi apiInstance = new EnvironmentsApi();
        Environment environment = ; // Environment | 
        try {
            apiInstance.create(environment);
        } catch (ApiException e) {
            System.err.println("Exception when calling EnvironmentsApi#create");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

Environment *environment = ; // 

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

// Create a new environment
[apiInstance createWith:environment
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaAltusDirectorApi = require('cloudera_altus_director_api');
var defaultClient = ClouderaAltusDirectorApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new ClouderaAltusDirectorApi.EnvironmentsApi()

var environment = ; // {Environment} 


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

using System;
using System.Diagnostics;
using cloudera.director.Api;
using cloudera.director.Client;
using cloudera.director.Model;

namespace Example
{
    public class createExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new EnvironmentsApi();
            var environment = new Environment(); // Environment | 

            try
            {
                // Create a new environment
                apiInstance.create(environment);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling EnvironmentsApi.create: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\EnvironmentsApi();
$environment = ; // Environment | 

try {
    $api_instance->create($environment);
} catch (Exception $e) {
    echo 'Exception when calling EnvironmentsApi->create: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::EnvironmentsApi->new();
my $environment = WWW::SwaggerClient::Object::Environment->new(); # Environment | 

eval { 
    $api_instance->create(environment => $environment);
};
if ($@) {
    warn "Exception when calling EnvironmentsApi->create: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.EnvironmentsApi()
environment =  # Environment | 

try: 
    # Create a new environment
    api_instance.create(environment)
except ApiException as e:
    print("Exception when calling EnvironmentsApi->create: %s\n" % e)

Parameters

Body parameters

Name	Description
environment *

Responses

Status: 201 - Environment created

Status: 302 - Environment already exists

Status: 400 - Invalid environment

delete

Delete an environment by name

/api/v8/environments/{name}

Usage and SDK Samples

curl -X DELETE -H "Accept: application/json" -H "Authorization: Basic [[basicHash]]" "https://localhost/api/v8/environments/{name}"

import com.cloudera.director.client.common.*;
import com.cloudera.director.client.common.auth.*;
import com.cloudera.director.client.common.model.*;
import com.cloudera.director.client.common.api.EnvironmentsApi;

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

public class EnvironmentsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        EnvironmentsApi apiInstance = new EnvironmentsApi();
        String name = name_example; // String | 
        try {
            apiInstance.delete(name);
        } catch (ApiException e) {
            System.err.println("Exception when calling EnvironmentsApi#delete");
            e.printStackTrace();
        }
    }
}

import com.cloudera.director.client.common.api.EnvironmentsApi;

public class EnvironmentsApiExample {

    public static void main(String[] args) {
        EnvironmentsApi apiInstance = new EnvironmentsApi();
        String name = name_example; // String | 
        try {
            apiInstance.delete(name);
        } catch (ApiException e) {
            System.err.println("Exception when calling EnvironmentsApi#delete");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *name = name_example; // 

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

// Delete an environment by name
[apiInstance deleteWith:name
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaAltusDirectorApi = require('cloudera_altus_director_api');
var defaultClient = ClouderaAltusDirectorApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new ClouderaAltusDirectorApi.EnvironmentsApi()

var name = name_example; // {String} 


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

using System;
using System.Diagnostics;
using cloudera.director.Api;
using cloudera.director.Client;
using cloudera.director.Model;

namespace Example
{
    public class deleteExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new EnvironmentsApi();
            var name = name_example;  // String | 

            try
            {
                // Delete an environment by name
                apiInstance.delete(name);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling EnvironmentsApi.delete: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\EnvironmentsApi();
$name = name_example; // String | 

try {
    $api_instance->delete($name);
} catch (Exception $e) {
    echo 'Exception when calling EnvironmentsApi->delete: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::EnvironmentsApi->new();
my $name = name_example; # String | 

eval { 
    $api_instance->delete(name => $name);
};
if ($@) {
    warn "Exception when calling EnvironmentsApi->delete: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    # Delete an environment by name
    api_instance.delete(name)
except ApiException as e:
    print("Exception when calling EnvironmentsApi->delete: %s\n" % e)

Parameters

Path parameters

Name	Description
name*	String Required

Responses

Status: 204 - Environment deleted

Status: 400 - Environment is not empty

getRedacted

Get an environment by name

/api/v8/environments/{name}

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Authorization: Basic [[basicHash]]" "https://localhost/api/v8/environments/{name}"

import com.cloudera.director.client.common.*;
import com.cloudera.director.client.common.auth.*;
import com.cloudera.director.client.common.model.*;
import com.cloudera.director.client.common.api.EnvironmentsApi;

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

public class EnvironmentsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        EnvironmentsApi apiInstance = new EnvironmentsApi();
        String name = name_example; // String | 
        try {
            Environment result = apiInstance.getRedacted(name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EnvironmentsApi#getRedacted");
            e.printStackTrace();
        }
    }
}

import com.cloudera.director.client.common.api.EnvironmentsApi;

public class EnvironmentsApiExample {

    public static void main(String[] args) {
        EnvironmentsApi apiInstance = new EnvironmentsApi();
        String name = name_example; // String | 
        try {
            Environment result = apiInstance.getRedacted(name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EnvironmentsApi#getRedacted");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *name = name_example; // 

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

// Get an environment by name
[apiInstance getRedactedWith:name
              completionHandler: ^(Environment output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaAltusDirectorApi = require('cloudera_altus_director_api');
var defaultClient = ClouderaAltusDirectorApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new ClouderaAltusDirectorApi.EnvironmentsApi()

var name = name_example; // {String} 


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

using System;
using System.Diagnostics;
using cloudera.director.Api;
using cloudera.director.Client;
using cloudera.director.Model;

namespace Example
{
    public class getRedactedExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new EnvironmentsApi();
            var name = name_example;  // String | 

            try
            {
                // Get an environment by name
                Environment result = apiInstance.getRedacted(name);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling EnvironmentsApi.getRedacted: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\EnvironmentsApi();
$name = name_example; // String | 

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

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::EnvironmentsApi->new();
my $name = name_example; # String | 

eval { 
    my $result = $api_instance->getRedacted(name => $name);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling EnvironmentsApi->getRedacted: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    # Get an environment by name
    api_response = api_instance.get_redacted(name)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EnvironmentsApi->getRedacted: %s\n" % e)

Parameters

Path parameters

Name	Description
name*	String Required

Responses

Status: 200 - OK

Schema

Status: 404 - Environment not found

list

List all environments

/api/v8/environments

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Authorization: Basic [[basicHash]]" "https://localhost/api/v8/environments"

import com.cloudera.director.client.common.*;
import com.cloudera.director.client.common.auth.*;
import com.cloudera.director.client.common.model.*;
import com.cloudera.director.client.common.api.EnvironmentsApi;

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

public class EnvironmentsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        EnvironmentsApi apiInstance = new EnvironmentsApi();
        try {
            array['String'] result = apiInstance.list();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EnvironmentsApi#list");
            e.printStackTrace();
        }
    }
}

import com.cloudera.director.client.common.api.EnvironmentsApi;

public class EnvironmentsApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];


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

// List all environments
[apiInstance listWithCompletionHandler: 
              ^(array['String'] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaAltusDirectorApi = require('cloudera_altus_director_api');
var defaultClient = ClouderaAltusDirectorApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new ClouderaAltusDirectorApi.EnvironmentsApi()

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

using System;
using System.Diagnostics;
using cloudera.director.Api;
using cloudera.director.Client;
using cloudera.director.Model;

namespace Example
{
    public class listExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new EnvironmentsApi();

            try
            {
                // List all environments
                array['String'] result = apiInstance.list();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling EnvironmentsApi.list: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\EnvironmentsApi();

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

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

eval { 
    my $result = $api_instance->list();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling EnvironmentsApi->list: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    # List all environments
    api_response = api_instance.list()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EnvironmentsApi->list: %s\n" % e)

Parameters

Responses

Status: 200 - OK

Schema

update

Update an existing environment

/api/v8/environments/{name}

Usage and SDK Samples

curl -X PUT -H "Accept: application/json" -H "Authorization: Basic [[basicHash]]" "https://localhost/api/v8/environments/{name}"

import com.cloudera.director.client.common.*;
import com.cloudera.director.client.common.auth.*;
import com.cloudera.director.client.common.model.*;
import com.cloudera.director.client.common.api.EnvironmentsApi;

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

public class EnvironmentsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        EnvironmentsApi apiInstance = new EnvironmentsApi();
        String name = name_example; // String | 
        Environment environment = ; // Environment | 
        try {
            apiInstance.update(name, environment);
        } catch (ApiException e) {
            System.err.println("Exception when calling EnvironmentsApi#update");
            e.printStackTrace();
        }
    }
}

import com.cloudera.director.client.common.api.EnvironmentsApi;

public class EnvironmentsApiExample {

    public static void main(String[] args) {
        EnvironmentsApi apiInstance = new EnvironmentsApi();
        String name = name_example; // String | 
        Environment environment = ; // Environment | 
        try {
            apiInstance.update(name, environment);
        } catch (ApiException e) {
            System.err.println("Exception when calling EnvironmentsApi#update");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *name = name_example; // 
Environment *environment = ; // 

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

// Update an existing environment
[apiInstance updateWith:name
    environment:environment
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaAltusDirectorApi = require('cloudera_altus_director_api');
var defaultClient = ClouderaAltusDirectorApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new ClouderaAltusDirectorApi.EnvironmentsApi()

var name = name_example; // {String} 

var environment = ; // {Environment} 


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

using System;
using System.Diagnostics;
using cloudera.director.Api;
using cloudera.director.Client;
using cloudera.director.Model;

namespace Example
{
    public class updateExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new EnvironmentsApi();
            var name = name_example;  // String | 
            var environment = new Environment(); // Environment | 

            try
            {
                // Update an existing environment
                apiInstance.update(name, environment);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling EnvironmentsApi.update: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\EnvironmentsApi();
$name = name_example; // String | 
$environment = ; // Environment | 

try {
    $api_instance->update($name, $environment);
} catch (Exception $e) {
    echo 'Exception when calling EnvironmentsApi->update: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::EnvironmentsApi->new();
my $name = name_example; # String | 
my $environment = WWW::SwaggerClient::Object::Environment->new(); # Environment | 

eval { 
    $api_instance->update(name => $name, environment => $environment);
};
if ($@) {
    warn "Exception when calling EnvironmentsApi->update: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.EnvironmentsApi()
name = name_example # String | 
environment =  # Environment | 

try: 
    # Update an existing environment
    api_instance.update(name, environment)
except ApiException as e:
    print("Exception when calling EnvironmentsApi->update: %s\n" % e)

Parameters

Path parameters

Name	Description
name*	String Required

Body parameters

Name	Description
environment *

Responses

Status: 202 - Updated environment accepted

Status: 400 - Validation error or rename not allowed

Status: 404 - Environment not found

updateProviderCredentials

Update provider credentials for a specific environment

/api/v8/environments/{name}/provider/credentials

Usage and SDK Samples

curl -X PUT -H "Accept: application/json" -H "Authorization: Basic [[basicHash]]" "https://localhost/api/v8/environments/{name}/provider/credentials"

import com.cloudera.director.client.common.*;
import com.cloudera.director.client.common.auth.*;
import com.cloudera.director.client.common.model.*;
import com.cloudera.director.client.common.api.EnvironmentsApi;

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

public class EnvironmentsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        EnvironmentsApi apiInstance = new EnvironmentsApi();
        String name = name_example; // String | 
        Object credentials = ; // Object | 
        try {
            apiInstance.updateProviderCredentials(name, credentials);
        } catch (ApiException e) {
            System.err.println("Exception when calling EnvironmentsApi#updateProviderCredentials");
            e.printStackTrace();
        }
    }
}

import com.cloudera.director.client.common.api.EnvironmentsApi;

public class EnvironmentsApiExample {

    public static void main(String[] args) {
        EnvironmentsApi apiInstance = new EnvironmentsApi();
        String name = name_example; // String | 
        Object credentials = ; // Object | 
        try {
            apiInstance.updateProviderCredentials(name, credentials);
        } catch (ApiException e) {
            System.err.println("Exception when calling EnvironmentsApi#updateProviderCredentials");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *name = name_example; // 
Object *credentials = ; // 

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

// Update provider credentials for a specific environment
[apiInstance updateProviderCredentialsWith:name
    credentials:credentials
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaAltusDirectorApi = require('cloudera_altus_director_api');
var defaultClient = ClouderaAltusDirectorApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new ClouderaAltusDirectorApi.EnvironmentsApi()

var name = name_example; // {String} 

var credentials = ; // {Object} 


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

using System;
using System.Diagnostics;
using cloudera.director.Api;
using cloudera.director.Client;
using cloudera.director.Model;

namespace Example
{
    public class updateProviderCredentialsExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new EnvironmentsApi();
            var name = name_example;  // String | 
            var credentials = new Object(); // Object | 

            try
            {
                // Update provider credentials for a specific environment
                apiInstance.updateProviderCredentials(name, credentials);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling EnvironmentsApi.updateProviderCredentials: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\EnvironmentsApi();
$name = name_example; // String | 
$credentials = ; // Object | 

try {
    $api_instance->updateProviderCredentials($name, $credentials);
} catch (Exception $e) {
    echo 'Exception when calling EnvironmentsApi->updateProviderCredentials: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::EnvironmentsApi->new();
my $name = name_example; # String | 
my $credentials = WWW::SwaggerClient::Object::Object->new(); # Object | 

eval { 
    $api_instance->updateProviderCredentials(name => $name, credentials => $credentials);
};
if ($@) {
    warn "Exception when calling EnvironmentsApi->updateProviderCredentials: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.EnvironmentsApi()
name = name_example # String | 
credentials =  # Object | 

try: 
    # Update provider credentials for a specific environment
    api_instance.update_provider_credentials(name, credentials)
except ApiException as e:
    print("Exception when calling EnvironmentsApi->updateProviderCredentials: %s\n" % e)

Parameters

Path parameters

Name	Description
name*	String Required

Body parameters

Name	Description
credentials *

Responses

Status: 202 - Updated environment accepted

Status: 400 - Validation error or rename not allowed

Status: 404 - Environment not found

Eula

get

Get the EULA

/api/v8/eula

Usage and SDK Samples

curl -X GET "https://localhost/api/v8/eula"

import com.cloudera.director.client.common.*;
import com.cloudera.director.client.common.auth.*;
import com.cloudera.director.client.common.model.*;
import com.cloudera.director.client.common.api.EulaApi;

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

public class EulaApiExample {

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

import com.cloudera.director.client.common.api.EulaApi;

public class EulaApiExample {

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


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

// Get the EULA
[apiInstance getWithCompletionHandler: 
              ^(Eula output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaAltusDirectorApi = require('cloudera_altus_director_api');

var api = new ClouderaAltusDirectorApi.EulaApi()

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

using System;
using System.Diagnostics;
using cloudera.director.Api;
using cloudera.director.Client;
using cloudera.director.Model;

namespace Example
{
    public class getExample
    {
        public void main()
        {
            
            var apiInstance = new EulaApi();

            try
            {
                // Get the EULA
                Eula result = apiInstance.get();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling EulaApi.get: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\EulaApi();

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

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

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

eval { 
    my $result = $api_instance->get();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling EulaApi->get: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

try: 
    # Get the EULA
    api_response = api_instance.get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EulaApi->get: %s\n" % e)

Parameters

Responses

Status: 200 - OK

Schema

update

Update the EULA

/api/v8/eula

Usage and SDK Samples

curl -X PUT "https://localhost/api/v8/eula"

import com.cloudera.director.client.common.*;
import com.cloudera.director.client.common.auth.*;
import com.cloudera.director.client.common.model.*;
import com.cloudera.director.client.common.api.EulaApi;

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

public class EulaApiExample {

    public static void main(String[] args) {
        
        EulaApi apiInstance = new EulaApi();
        Eula eula = ; // Eula | 
        try {
            apiInstance.update(eula);
        } catch (ApiException e) {
            System.err.println("Exception when calling EulaApi#update");
            e.printStackTrace();
        }
    }
}

import com.cloudera.director.client.common.api.EulaApi;

public class EulaApiExample {

    public static void main(String[] args) {
        EulaApi apiInstance = new EulaApi();
        Eula eula = ; // Eula | 
        try {
            apiInstance.update(eula);
        } catch (ApiException e) {
            System.err.println("Exception when calling EulaApi#update");
            e.printStackTrace();
        }
    }
}

Eula *eula = ; // 

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

// Update the EULA
[apiInstance updateWith:eula
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaAltusDirectorApi = require('cloudera_altus_director_api');

var api = new ClouderaAltusDirectorApi.EulaApi()

var eula = ; // {Eula} 


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

using System;
using System.Diagnostics;
using cloudera.director.Api;
using cloudera.director.Client;
using cloudera.director.Model;

namespace Example
{
    public class updateExample
    {
        public void main()
        {
            
            var apiInstance = new EulaApi();
            var eula = new Eula(); // Eula | 

            try
            {
                // Update the EULA
                apiInstance.update(eula);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling EulaApi.update: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\EulaApi();
$eula = ; // Eula | 

try {
    $api_instance->update($eula);
} catch (Exception $e) {
    echo 'Exception when calling EulaApi->update: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::EulaApi->new();
my $eula = WWW::SwaggerClient::Object::Eula->new(); # Eula | 

eval { 
    $api_instance->update(eula => $eula);
};
if ($@) {
    warn "Exception when calling EulaApi->update: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.EulaApi()
eula =  # Eula | 

try: 
    # Update the EULA
    api_instance.update(eula)
except ApiException as e:
    print("Exception when calling EulaApi->update: %s\n" % e)

Parameters

Body parameters

Name	Description
eula *

Responses

Status: 200 - OK

Status: 400 - Invalid eula data.

ImportClientConfig

importClientConfig

Import Client Config

/api/v8/import

Usage and SDK Samples

curl -X POST -H "Content-Type: text/plain" -H "Authorization: Basic [[basicHash]]" "https://localhost/api/v8/import?clusterName=&deploymentName=&environmentName="

import com.cloudera.director.client.common.*;
import com.cloudera.director.client.common.auth.*;
import com.cloudera.director.client.common.model.*;
import com.cloudera.director.client.common.api.ImportClientConfigApi;

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

public class ImportClientConfigApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        ImportClientConfigApi apiInstance = new ImportClientConfigApi();
        String clientConfig = clientConfig_example; // String | 
        String clusterName = clusterName_example; // String | 
        String deploymentName = deploymentName_example; // String | 
        String environmentName = environmentName_example; // String | 
        try {
            ImportResult result = apiInstance.importClientConfig(clientConfig, clusterName, deploymentName, environmentName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ImportClientConfigApi#importClientConfig");
            e.printStackTrace();
        }
    }
}

import com.cloudera.director.client.common.api.ImportClientConfigApi;

public class ImportClientConfigApiExample {

    public static void main(String[] args) {
        ImportClientConfigApi apiInstance = new ImportClientConfigApi();
        String clientConfig = clientConfig_example; // String | 
        String clusterName = clusterName_example; // String | 
        String deploymentName = deploymentName_example; // String | 
        String environmentName = environmentName_example; // String | 
        try {
            ImportResult result = apiInstance.importClientConfig(clientConfig, clusterName, deploymentName, environmentName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ImportClientConfigApi#importClientConfig");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *clientConfig = clientConfig_example; // 
String *clusterName = clusterName_example; //  (optional)
String *deploymentName = deploymentName_example; //  (optional)
String *environmentName = environmentName_example; //  (optional)

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

// Import Client Config
[apiInstance importClientConfigWith:clientConfig
    clusterName:clusterName
    deploymentName:deploymentName
    environmentName:environmentName
              completionHandler: ^(ImportResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaAltusDirectorApi = require('cloudera_altus_director_api');
var defaultClient = ClouderaAltusDirectorApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new ClouderaAltusDirectorApi.ImportClientConfigApi()

var clientConfig = clientConfig_example; // {String} 

var opts = { 
  'clusterName': clusterName_example, // {String} 
  'deploymentName': deploymentName_example, // {String} 
  'environmentName': environmentName_example // {String} 
};

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

using System;
using System.Diagnostics;
using cloudera.director.Api;
using cloudera.director.Client;
using cloudera.director.Model;

namespace Example
{
    public class importClientConfigExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ImportClientConfigApi();
            var clientConfig = clientConfig_example;  // String | 
            var clusterName = clusterName_example;  // String |  (optional) 
            var deploymentName = deploymentName_example;  // String |  (optional) 
            var environmentName = environmentName_example;  // String |  (optional) 

            try
            {
                // Import Client Config
                ImportResult result = apiInstance.importClientConfig(clientConfig, clusterName, deploymentName, environmentName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ImportClientConfigApi.importClientConfig: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ImportClientConfigApi();
$clientConfig = clientConfig_example; // String | 
$clusterName = clusterName_example; // String | 
$deploymentName = deploymentName_example; // String | 
$environmentName = environmentName_example; // String | 

try {
    $result = $api_instance->importClientConfig($clientConfig, $clusterName, $deploymentName, $environmentName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ImportClientConfigApi->importClientConfig: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ImportClientConfigApi->new();
my $clientConfig = WWW::SwaggerClient::Object::String->new(); # String | 
my $clusterName = clusterName_example; # String | 
my $deploymentName = deploymentName_example; # String | 
my $environmentName = environmentName_example; # String | 

eval { 
    my $result = $api_instance->importClientConfig(clientConfig => $clientConfig, clusterName => $clusterName, deploymentName => $deploymentName, environmentName => $environmentName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ImportClientConfigApi->importClientConfig: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ImportClientConfigApi()
clientConfig = clientConfig_example # String | 
clusterName = clusterName_example # String |  (optional)
deploymentName = deploymentName_example # String |  (optional)
environmentName = environmentName_example # String |  (optional)

try: 
    # Import Client Config
    api_response = api_instance.import_client_config(clientConfig, clusterName=clusterName, deploymentName=deploymentName, environmentName=environmentName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ImportClientConfigApi->importClientConfig: %s\n" % e)

Parameters

Body parameters

Name	Description
clientConfig *

Query parameters

Name	Description
clusterName	String
deploymentName	String
environmentName	String

Responses

Status: 200 - successful operation

Schema

Status: 202 - Import request accepted

InstanceTemplates

create

Create a new instance template

/api/v8/environments/{environment}/templates/instances

Usage and SDK Samples

curl -X POST -H "Accept: application/json" -H "Authorization: Basic [[basicHash]]" "https://localhost/api/v8/environments/{environment}/templates/instances"

import com.cloudera.director.client.common.*;
import com.cloudera.director.client.common.auth.*;
import com.cloudera.director.client.common.model.*;
import com.cloudera.director.client.common.api.InstanceTemplatesApi;

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

public class InstanceTemplatesApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        InstanceTemplatesApi apiInstance = new InstanceTemplatesApi();
        String environment = environment_example; // String | 
        InstanceTemplate instanceTemplate = ; // InstanceTemplate | 
        try {
            apiInstance.create(environment, instanceTemplate);
        } catch (ApiException e) {
            System.err.println("Exception when calling InstanceTemplatesApi#create");
            e.printStackTrace();
        }
    }
}

import com.cloudera.director.client.common.api.InstanceTemplatesApi;

public class InstanceTemplatesApiExample {

    public static void main(String[] args) {
        InstanceTemplatesApi apiInstance = new InstanceTemplatesApi();
        String environment = environment_example; // String | 
        InstanceTemplate instanceTemplate = ; // InstanceTemplate | 
        try {
            apiInstance.create(environment, instanceTemplate);
        } catch (ApiException e) {
            System.err.println("Exception when calling InstanceTemplatesApi#create");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *environment = environment_example; // 
InstanceTemplate *instanceTemplate = ; // 

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

// Create a new instance template
[apiInstance createWith:environment
    instanceTemplate:instanceTemplate
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaAltusDirectorApi = require('cloudera_altus_director_api');
var defaultClient = ClouderaAltusDirectorApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new ClouderaAltusDirectorApi.InstanceTemplatesApi()

var environment = environment_example; // {String} 

var instanceTemplate = ; // {InstanceTemplate} 


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

using System;
using System.Diagnostics;
using cloudera.director.Api;
using cloudera.director.Client;
using cloudera.director.Model;

namespace Example
{
    public class createExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new InstanceTemplatesApi();
            var environment = environment_example;  // String | 
            var instanceTemplate = new InstanceTemplate(); // InstanceTemplate | 

            try
            {
                // Create a new instance template
                apiInstance.create(environment, instanceTemplate);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling InstanceTemplatesApi.create: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\InstanceTemplatesApi();
$environment = environment_example; // String | 
$instanceTemplate = ; // InstanceTemplate | 

try {
    $api_instance->create($environment, $instanceTemplate);
} catch (Exception $e) {
    echo 'Exception when calling InstanceTemplatesApi->create: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::InstanceTemplatesApi->new();
my $environment = environment_example; # String | 
my $instanceTemplate = WWW::SwaggerClient::Object::InstanceTemplate->new(); # InstanceTemplate | 

eval { 
    $api_instance->create(environment => $environment, instanceTemplate => $instanceTemplate);
};
if ($@) {
    warn "Exception when calling InstanceTemplatesApi->create: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.InstanceTemplatesApi()
environment = environment_example # String | 
instanceTemplate =  # InstanceTemplate | 

try: 
    # Create a new instance template
    api_instance.create(environment, instanceTemplate)
except ApiException as e:
    print("Exception when calling InstanceTemplatesApi->create: %s\n" % e)

Parameters

Path parameters

Name	Description
environment*	String Required

Body parameters

Name	Description
instanceTemplate *

Responses

Status: 201 - Instance template created

Status: 302 - Instance template already exists

Status: 400 - Invalid instance template

Status: 404 - Environment not found

delete

Delete an instance template by name

/api/v8/environments/{environment}/templates/instances/{template}

Usage and SDK Samples

curl -X DELETE -H "Accept: application/json" -H "Authorization: Basic [[basicHash]]" "https://localhost/api/v8/environments/{environment}/templates/instances/{template}"

import com.cloudera.director.client.common.*;
import com.cloudera.director.client.common.auth.*;
import com.cloudera.director.client.common.model.*;
import com.cloudera.director.client.common.api.InstanceTemplatesApi;

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

public class InstanceTemplatesApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        InstanceTemplatesApi apiInstance = new InstanceTemplatesApi();
        String environment = environment_example; // String | 
        String template = template_example; // String | 
        try {
            apiInstance.delete(environment, template);
        } catch (ApiException e) {
            System.err.println("Exception when calling InstanceTemplatesApi#delete");
            e.printStackTrace();
        }
    }
}

import com.cloudera.director.client.common.api.InstanceTemplatesApi;

public class InstanceTemplatesApiExample {

    public static void main(String[] args) {
        InstanceTemplatesApi apiInstance = new InstanceTemplatesApi();
        String environment = environment_example; // String | 
        String template = template_example; // String | 
        try {
            apiInstance.delete(environment, template);
        } catch (ApiException e) {
            System.err.println("Exception when calling InstanceTemplatesApi#delete");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *environment = environment_example; // 
String *template = template_example; // 

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

// Delete an instance template by name
[apiInstance deleteWith:environment
    template:template
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaAltusDirectorApi = require('cloudera_altus_director_api');
var defaultClient = ClouderaAltusDirectorApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new ClouderaAltusDirectorApi.InstanceTemplatesApi()

var environment = environment_example; // {String} 

var template = template_example; // {String} 


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

using System;
using System.Diagnostics;
using cloudera.director.Api;
using cloudera.director.Client;
using cloudera.director.Model;

namespace Example
{
    public class deleteExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new InstanceTemplatesApi();
            var environment = environment_example;  // String | 
            var template = template_example;  // String | 

            try
            {
                // Delete an instance template by name
                apiInstance.delete(environment, template);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling InstanceTemplatesApi.delete: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\InstanceTemplatesApi();
$environment = environment_example; // String | 
$template = template_example; // String | 

try {
    $api_instance->delete($environment, $template);
} catch (Exception $e) {
    echo 'Exception when calling InstanceTemplatesApi->delete: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::InstanceTemplatesApi->new();
my $environment = environment_example; # String | 
my $template = template_example; # String | 

eval { 
    $api_instance->delete(environment => $environment, template => $template);
};
if ($@) {
    warn "Exception when calling InstanceTemplatesApi->delete: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.InstanceTemplatesApi()
environment = environment_example # String | 
template = template_example # String | 

try: 
    # Delete an instance template by name
    api_instance.delete(environment, template)
except ApiException as e:
    print("Exception when calling InstanceTemplatesApi->delete: %s\n" % e)

Parameters

Path parameters

Name	Description
environment*	String Required
template*	String Required

Responses

Status: 204 - Instance template deleted

Status: 404 - Environment not found

get

Get an instance template by name

/api/v8/environments/{environment}/templates/instances/{template}

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Authorization: Basic [[basicHash]]" "https://localhost/api/v8/environments/{environment}/templates/instances/{template}"

import com.cloudera.director.client.common.*;
import com.cloudera.director.client.common.auth.*;
import com.cloudera.director.client.common.model.*;
import com.cloudera.director.client.common.api.InstanceTemplatesApi;

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

public class InstanceTemplatesApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        InstanceTemplatesApi apiInstance = new InstanceTemplatesApi();
        String environment = environment_example; // String | 
        String template = template_example; // String | 
        try {
            InstanceTemplate result = apiInstance.get(environment, template);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling InstanceTemplatesApi#get");
            e.printStackTrace();
        }
    }
}

import com.cloudera.director.client.common.api.InstanceTemplatesApi;

public class InstanceTemplatesApiExample {

    public static void main(String[] args) {
        InstanceTemplatesApi apiInstance = new InstanceTemplatesApi();
        String environment = environment_example; // String | 
        String template = template_example; // String | 
        try {
            InstanceTemplate result = apiInstance.get(environment, template);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling InstanceTemplatesApi#get");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *environment = environment_example; // 
String *template = template_example; // 

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

// Get an instance template by name
[apiInstance getWith:environment
    template:template
              completionHandler: ^(InstanceTemplate output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaAltusDirectorApi = require('cloudera_altus_director_api');
var defaultClient = ClouderaAltusDirectorApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new ClouderaAltusDirectorApi.InstanceTemplatesApi()

var environment = environment_example; // {String} 

var template = template_example; // {String} 


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

using System;
using System.Diagnostics;
using cloudera.director.Api;
using cloudera.director.Client;
using cloudera.director.Model;

namespace Example
{
    public class getExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new InstanceTemplatesApi();
            var environment = environment_example;  // String | 
            var template = template_example;  // String | 

            try
            {
                // Get an instance template by name
                InstanceTemplate result = apiInstance.get(environment, template);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling InstanceTemplatesApi.get: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\InstanceTemplatesApi();
$environment = environment_example; // String | 
$template = template_example; // String | 

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

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::InstanceTemplatesApi->new();
my $environment = environment_example; # String | 
my $template = template_example; # String | 

eval { 
    my $result = $api_instance->get(environment => $environment, template => $template);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling InstanceTemplatesApi->get: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.InstanceTemplatesApi()
environment = environment_example # String | 
template = template_example # String | 

try: 
    # Get an instance template by name
    api_response = api_instance.get(environment, template)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling InstanceTemplatesApi->get: %s\n" % e)

Parameters

Path parameters

Name	Description
environment*	String Required
template*	String Required

Responses

Status: 200 - OK

Schema

Status: 404 - Entity not found

list

List all instance templates

/api/v8/environments/{environment}/templates/instances

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Authorization: Basic [[basicHash]]" "https://localhost/api/v8/environments/{environment}/templates/instances"

import com.cloudera.director.client.common.*;
import com.cloudera.director.client.common.auth.*;
import com.cloudera.director.client.common.model.*;
import com.cloudera.director.client.common.api.InstanceTemplatesApi;

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

public class InstanceTemplatesApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        InstanceTemplatesApi apiInstance = new InstanceTemplatesApi();
        String environment = environment_example; // String | 
        try {
            array['String'] result = apiInstance.list(environment);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling InstanceTemplatesApi#list");
            e.printStackTrace();
        }
    }
}

import com.cloudera.director.client.common.api.InstanceTemplatesApi;

public class InstanceTemplatesApiExample {

    public static void main(String[] args) {
        InstanceTemplatesApi apiInstance = new InstanceTemplatesApi();
        String environment = environment_example; // String | 
        try {
            array['String'] result = apiInstance.list(environment);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling InstanceTemplatesApi#list");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *environment = environment_example; // 

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

// List all instance templates
[apiInstance listWith:environment
              completionHandler: ^(array['String'] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaAltusDirectorApi = require('cloudera_altus_director_api');
var defaultClient = ClouderaAltusDirectorApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new ClouderaAltusDirectorApi.InstanceTemplatesApi()

var environment = environment_example; // {String} 


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

using System;
using System.Diagnostics;
using cloudera.director.Api;
using cloudera.director.Client;
using cloudera.director.Model;

namespace Example
{
    public class listExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new InstanceTemplatesApi();
            var environment = environment_example;  // String | 

            try
            {
                // List all instance templates
                array['String'] result = apiInstance.list(environment);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling InstanceTemplatesApi.list: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\InstanceTemplatesApi();
$environment = environment_example; // String | 

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

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::InstanceTemplatesApi->new();
my $environment = environment_example; # String | 

eval { 
    my $result = $api_instance->list(environment => $environment);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling InstanceTemplatesApi->list: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.InstanceTemplatesApi()
environment = environment_example # String | 

try: 
    # List all instance templates
    api_response = api_instance.list(environment)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling InstanceTemplatesApi->list: %s\n" % e)

Parameters

Path parameters

Name	Description
environment*	String Required

Responses

Status: 200 - OK

Schema

Status: 404 - Environment not found

update

Update an existing instance template

/api/v8/environments/{environment}/templates/instances/{template}

Usage and SDK Samples

curl -X PUT -H "Accept: application/json" -H "Authorization: Basic [[basicHash]]" "https://localhost/api/v8/environments/{environment}/templates/instances/{template}"

import com.cloudera.director.client.common.*;
import com.cloudera.director.client.common.auth.*;
import com.cloudera.director.client.common.model.*;
import com.cloudera.director.client.common.api.InstanceTemplatesApi;

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

public class InstanceTemplatesApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        InstanceTemplatesApi apiInstance = new InstanceTemplatesApi();
        String environment = environment_example; // String | 
        String template = template_example; // String | 
        InstanceTemplate instanceTemplate = ; // InstanceTemplate | 
        try {
            apiInstance.update(environment, template, instanceTemplate);
        } catch (ApiException e) {
            System.err.println("Exception when calling InstanceTemplatesApi#update");
            e.printStackTrace();
        }
    }
}

import com.cloudera.director.client.common.api.InstanceTemplatesApi;

public class InstanceTemplatesApiExample {

    public static void main(String[] args) {
        InstanceTemplatesApi apiInstance = new InstanceTemplatesApi();
        String environment = environment_example; // String | 
        String template = template_example; // String | 
        InstanceTemplate instanceTemplate = ; // InstanceTemplate | 
        try {
            apiInstance.update(environment, template, instanceTemplate);
        } catch (ApiException e) {
            System.err.println("Exception when calling InstanceTemplatesApi#update");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *environment = environment_example; // 
String *template = template_example; // 
InstanceTemplate *instanceTemplate = ; // 

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

// Update an existing instance template
[apiInstance updateWith:environment
    template:template
    instanceTemplate:instanceTemplate
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaAltusDirectorApi = require('cloudera_altus_director_api');
var defaultClient = ClouderaAltusDirectorApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new ClouderaAltusDirectorApi.InstanceTemplatesApi()

var environment = environment_example; // {String} 

var template = template_example; // {String} 

var instanceTemplate = ; // {InstanceTemplate} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.update(environment, template, instanceTemplate, callback);

using System;
using System.Diagnostics;
using cloudera.director.Api;
using cloudera.director.Client;
using cloudera.director.Model;

namespace Example
{
    public class updateExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new InstanceTemplatesApi();
            var environment = environment_example;  // String | 
            var template = template_example;  // String | 
            var instanceTemplate = new InstanceTemplate(); // InstanceTemplate | 

            try
            {
                // Update an existing instance template
                apiInstance.update(environment, template, instanceTemplate);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling InstanceTemplatesApi.update: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\InstanceTemplatesApi();
$environment = environment_example; // String | 
$template = template_example; // String | 
$instanceTemplate = ; // InstanceTemplate | 

try {
    $api_instance->update($environment, $template, $instanceTemplate);
} catch (Exception $e) {
    echo 'Exception when calling InstanceTemplatesApi->update: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::InstanceTemplatesApi->new();
my $environment = environment_example; # String | 
my $template = template_example; # String | 
my $instanceTemplate = WWW::SwaggerClient::Object::InstanceTemplate->new(); # InstanceTemplate | 

eval { 
    $api_instance->update(environment => $environment, template => $template, instanceTemplate => $instanceTemplate);
};
if ($@) {
    warn "Exception when calling InstanceTemplatesApi->update: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.InstanceTemplatesApi()
environment = environment_example # String | 
template = template_example # String | 
instanceTemplate =  # InstanceTemplate | 

try: 
    # Update an existing instance template
    api_instance.update(environment, template, instanceTemplate)
except ApiException as e:
    print("Exception when calling InstanceTemplatesApi->update: %s\n" % e)

Parameters

Path parameters

Name	Description
environment*	String Required
template*	String Required

Body parameters

Name	Description
instanceTemplate *

Responses

Status: 204 - Accepted updated instance template

Status: 400 - Invalid instance template

Notifications

get

Get system notification messages

/api/v8/notifications

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Authorization: Basic [[basicHash]]" "https://localhost/api/v8/notifications"

import com.cloudera.director.client.common.*;
import com.cloudera.director.client.common.auth.*;
import com.cloudera.director.client.common.model.*;
import com.cloudera.director.client.common.api.NotificationsApi;

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

public class NotificationsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        NotificationsApi apiInstance = new NotificationsApi();
        try {
            array[Notification] result = apiInstance.get();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling NotificationsApi#get");
            e.printStackTrace();
        }
    }
}

import com.cloudera.director.client.common.api.NotificationsApi;

public class NotificationsApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];


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

// Get system notification messages
[apiInstance getWithCompletionHandler: 
              ^(array[Notification] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaAltusDirectorApi = require('cloudera_altus_director_api');
var defaultClient = ClouderaAltusDirectorApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new ClouderaAltusDirectorApi.NotificationsApi()

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

using System;
using System.Diagnostics;
using cloudera.director.Api;
using cloudera.director.Client;
using cloudera.director.Model;

namespace Example
{
    public class getExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new NotificationsApi();

            try
            {
                // Get system notification messages
                array[Notification] result = apiInstance.get();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling NotificationsApi.get: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\NotificationsApi();

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

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

eval { 
    my $result = $api_instance->get();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling NotificationsApi->get: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    # Get system notification messages
    api_response = api_instance.get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NotificationsApi->get: %s\n" % e)

Parameters

Responses

Status: 200 - OK

Schema

ProviderMetadata

get

Get a provider by name

/api/v8/metadata/providers/{providerId}

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Authorization: Basic [[basicHash]]" "https://localhost/api/v8/metadata/providers/{providerId}"

import com.cloudera.director.client.common.*;
import com.cloudera.director.client.common.auth.*;
import com.cloudera.director.client.common.model.*;
import com.cloudera.director.client.common.api.ProviderMetadataApi;

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

public class ProviderMetadataApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        ProviderMetadataApi apiInstance = new ProviderMetadataApi();
        String providerId = providerId_example; // String | 
        try {
            CloudProviderMetadata result = apiInstance.get(providerId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProviderMetadataApi#get");
            e.printStackTrace();
        }
    }
}

import com.cloudera.director.client.common.api.ProviderMetadataApi;

public class ProviderMetadataApiExample {

    public static void main(String[] args) {
        ProviderMetadataApi apiInstance = new ProviderMetadataApi();
        String providerId = providerId_example; // String | 
        try {
            CloudProviderMetadata result = apiInstance.get(providerId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProviderMetadataApi#get");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *providerId = providerId_example; // 

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

// Get a provider by name
[apiInstance getWith:providerId
              completionHandler: ^(CloudProviderMetadata output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaAltusDirectorApi = require('cloudera_altus_director_api');
var defaultClient = ClouderaAltusDirectorApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new ClouderaAltusDirectorApi.ProviderMetadataApi()

var providerId = providerId_example; // {String} 


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

using System;
using System.Diagnostics;
using cloudera.director.Api;
using cloudera.director.Client;
using cloudera.director.Model;

namespace Example
{
    public class getExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ProviderMetadataApi();
            var providerId = providerId_example;  // String | 

            try
            {
                // Get a provider by name
                CloudProviderMetadata result = apiInstance.get(providerId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProviderMetadataApi.get: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ProviderMetadataApi();
$providerId = providerId_example; // String | 

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

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ProviderMetadataApi->new();
my $providerId = providerId_example; # String | 

eval { 
    my $result = $api_instance->get(providerId => $providerId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProviderMetadataApi->get: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ProviderMetadataApi()
providerId = providerId_example # String | 

try: 
    # Get a provider by name
    api_response = api_instance.get(providerId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProviderMetadataApi->get: %s\n" % e)

Parameters

Path parameters

Name	Description
providerId*	String Required

Responses

Status: 200 - OK

Schema

Status: 404 - Not found

list

List all provider metadata

/api/v8/metadata/providers

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Authorization: Basic [[basicHash]]" "https://localhost/api/v8/metadata/providers"

import com.cloudera.director.client.common.*;
import com.cloudera.director.client.common.auth.*;
import com.cloudera.director.client.common.model.*;
import com.cloudera.director.client.common.api.ProviderMetadataApi;

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

public class ProviderMetadataApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        ProviderMetadataApi apiInstance = new ProviderMetadataApi();
        try {
            array[CloudProviderMetadata] result = apiInstance.list();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProviderMetadataApi#list");
            e.printStackTrace();
        }
    }
}

import com.cloudera.director.client.common.api.ProviderMetadataApi;

public class ProviderMetadataApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];


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

// List all provider metadata
[apiInstance listWithCompletionHandler: 
              ^(array[CloudProviderMetadata] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaAltusDirectorApi = require('cloudera_altus_director_api');
var defaultClient = ClouderaAltusDirectorApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new ClouderaAltusDirectorApi.ProviderMetadataApi()

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

using System;
using System.Diagnostics;
using cloudera.director.Api;
using cloudera.director.Client;
using cloudera.director.Model;

namespace Example
{
    public class listExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ProviderMetadataApi();

            try
            {
                // List all provider metadata
                array[CloudProviderMetadata] result = apiInstance.list();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProviderMetadataApi.list: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ProviderMetadataApi();

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

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

eval { 
    my $result = $api_instance->list();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProviderMetadataApi->list: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    # List all provider metadata
    api_response = api_instance.list()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProviderMetadataApi->list: %s\n" % e)

Parameters

Responses

Status: 200 - OK

Schema

Users

create

Create a new user

/api/v8/users

Usage and SDK Samples

curl -X POST -H "Accept: application/json" -H "Authorization: Basic [[basicHash]]" "https://localhost/api/v8/users"

import com.cloudera.director.client.common.*;
import com.cloudera.director.client.common.auth.*;
import com.cloudera.director.client.common.model.*;
import com.cloudera.director.client.common.api.UsersApi;

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

public class UsersApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        UsersApi apiInstance = new UsersApi();
        User user = ; // User | 
        try {
            apiInstance.create(user);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersApi#create");
            e.printStackTrace();
        }
    }
}

import com.cloudera.director.client.common.api.UsersApi;

public class UsersApiExample {

    public static void main(String[] args) {
        UsersApi apiInstance = new UsersApi();
        User user = ; // User | 
        try {
            apiInstance.create(user);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersApi#create");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

User *user = ; // 

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

// Create a new user
[apiInstance createWith:user
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaAltusDirectorApi = require('cloudera_altus_director_api');
var defaultClient = ClouderaAltusDirectorApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new ClouderaAltusDirectorApi.UsersApi()

var user = ; // {User} 


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

using System;
using System.Diagnostics;
using cloudera.director.Api;
using cloudera.director.Client;
using cloudera.director.Model;

namespace Example
{
    public class createExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new UsersApi();
            var user = new User(); // User | 

            try
            {
                // Create a new user
                apiInstance.create(user);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling UsersApi.create: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\UsersApi();
$user = ; // User | 

try {
    $api_instance->create($user);
} catch (Exception $e) {
    echo 'Exception when calling UsersApi->create: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::UsersApi->new();
my $user = WWW::SwaggerClient::Object::User->new(); # User | 

eval { 
    $api_instance->create(user => $user);
};
if ($@) {
    warn "Exception when calling UsersApi->create: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.UsersApi()
user =  # User | 

try: 
    # Create a new user
    api_instance.create(user)
except ApiException as e:
    print("Exception when calling UsersApi->create: %s\n" % e)

Parameters

Body parameters

Name	Description
user *

Responses

Status: 201 - User created

Status: 302 - User already exists

Status: 400 - Invalid user

currentRedacted

Get the current user

/api/v8/users/current

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Authorization: Basic [[basicHash]]" "https://localhost/api/v8/users/current"

import com.cloudera.director.client.common.*;
import com.cloudera.director.client.common.auth.*;
import com.cloudera.director.client.common.model.*;
import com.cloudera.director.client.common.api.UsersApi;

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

public class UsersApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        UsersApi apiInstance = new UsersApi();
        try {
            User result = apiInstance.currentRedacted();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersApi#currentRedacted");
            e.printStackTrace();
        }
    }
}

import com.cloudera.director.client.common.api.UsersApi;

public class UsersApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];


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

// Get the current user
[apiInstance currentRedactedWithCompletionHandler: 
              ^(User output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaAltusDirectorApi = require('cloudera_altus_director_api');
var defaultClient = ClouderaAltusDirectorApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new ClouderaAltusDirectorApi.UsersApi()

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

using System;
using System.Diagnostics;
using cloudera.director.Api;
using cloudera.director.Client;
using cloudera.director.Model;

namespace Example
{
    public class currentRedactedExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new UsersApi();

            try
            {
                // Get the current user
                User result = apiInstance.currentRedacted();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling UsersApi.currentRedacted: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\UsersApi();

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

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

eval { 
    my $result = $api_instance->currentRedacted();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UsersApi->currentRedacted: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    # Get the current user
    api_response = api_instance.current_redacted()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UsersApi->currentRedacted: %s\n" % e)

Parameters

Responses

Status: 200 - OK

Schema

delete

Delete a user by username

/api/v8/users/{username}

Usage and SDK Samples

curl -X DELETE -H "Accept: application/json" -H "Authorization: Basic [[basicHash]]" "https://localhost/api/v8/users/{username}"

import com.cloudera.director.client.common.*;
import com.cloudera.director.client.common.auth.*;
import com.cloudera.director.client.common.model.*;
import com.cloudera.director.client.common.api.UsersApi;

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

public class UsersApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        UsersApi apiInstance = new UsersApi();
        String username = username_example; // String | 
        try {
            apiInstance.delete(username);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersApi#delete");
            e.printStackTrace();
        }
    }
}

import com.cloudera.director.client.common.api.UsersApi;

public class UsersApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *username = username_example; // 

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

// Delete a user by username
[apiInstance deleteWith:username
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaAltusDirectorApi = require('cloudera_altus_director_api');
var defaultClient = ClouderaAltusDirectorApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new ClouderaAltusDirectorApi.UsersApi()

var username = username_example; // {String} 


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

using System;
using System.Diagnostics;
using cloudera.director.Api;
using cloudera.director.Client;
using cloudera.director.Model;

namespace Example
{
    public class deleteExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

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

            try
            {
                // Delete a user by username
                apiInstance.delete(username);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling UsersApi.delete: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\UsersApi();
$username = username_example; // String | 

try {
    $api_instance->delete($username);
} catch (Exception $e) {
    echo 'Exception when calling UsersApi->delete: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

eval { 
    $api_instance->delete(username => $username);
};
if ($@) {
    warn "Exception when calling UsersApi->delete: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    # Delete a user by username
    api_instance.delete(username)
except ApiException as e:
    print("Exception when calling UsersApi->delete: %s\n" % e)

Parameters

Path parameters

Name	Description
username*	String Required

Responses

Status: 204 - User deleted

getRedacted

Get a user by username

/api/v8/users/{username}

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Authorization: Basic [[basicHash]]" "https://localhost/api/v8/users/{username}"

import com.cloudera.director.client.common.*;
import com.cloudera.director.client.common.auth.*;
import com.cloudera.director.client.common.model.*;
import com.cloudera.director.client.common.api.UsersApi;

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

public class UsersApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        UsersApi apiInstance = new UsersApi();
        String username = username_example; // String | 
        try {
            User result = apiInstance.getRedacted(username);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersApi#getRedacted");
            e.printStackTrace();
        }
    }
}

import com.cloudera.director.client.common.api.UsersApi;

public class UsersApiExample {

    public static void main(String[] args) {
        UsersApi apiInstance = new UsersApi();
        String username = username_example; // String | 
        try {
            User result = apiInstance.getRedacted(username);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersApi#getRedacted");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *username = username_example; // 

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

// Get a user by username
[apiInstance getRedactedWith:username
              completionHandler: ^(User output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaAltusDirectorApi = require('cloudera_altus_director_api');
var defaultClient = ClouderaAltusDirectorApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new ClouderaAltusDirectorApi.UsersApi()

var username = username_example; // {String} 


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

using System;
using System.Diagnostics;
using cloudera.director.Api;
using cloudera.director.Client;
using cloudera.director.Model;

namespace Example
{
    public class getRedactedExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

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

            try
            {
                // Get a user by username
                User result = apiInstance.getRedacted(username);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling UsersApi.getRedacted: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\UsersApi();
$username = username_example; // String | 

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

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

eval { 
    my $result = $api_instance->getRedacted(username => $username);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UsersApi->getRedacted: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    # Get a user by username
    api_response = api_instance.get_redacted(username)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UsersApi->getRedacted: %s\n" % e)

Parameters

Path parameters

Name	Description
username*	String Required

Responses

Status: 200 - OK

Schema

Status: 404 - User not found

list

List all users

/api/v8/users

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Authorization: Basic [[basicHash]]" "https://localhost/api/v8/users"

import com.cloudera.director.client.common.*;
import com.cloudera.director.client.common.auth.*;
import com.cloudera.director.client.common.model.*;
import com.cloudera.director.client.common.api.UsersApi;

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

public class UsersApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        UsersApi apiInstance = new UsersApi();
        try {
            array['String'] result = apiInstance.list();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersApi#list");
            e.printStackTrace();
        }
    }
}

import com.cloudera.director.client.common.api.UsersApi;

public class UsersApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];


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

// List all users
[apiInstance listWithCompletionHandler: 
              ^(array['String'] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaAltusDirectorApi = require('cloudera_altus_director_api');
var defaultClient = ClouderaAltusDirectorApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new ClouderaAltusDirectorApi.UsersApi()

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

using System;
using System.Diagnostics;
using cloudera.director.Api;
using cloudera.director.Client;
using cloudera.director.Model;

namespace Example
{
    public class listExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new UsersApi();

            try
            {
                // List all users
                array['String'] result = apiInstance.list();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling UsersApi.list: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\UsersApi();

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

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

eval { 
    my $result = $api_instance->list();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UsersApi->list: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    # List all users
    api_response = api_instance.list()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UsersApi->list: %s\n" % e)

Parameters

Responses

Status: 200 - OK

Schema

update

Update an existing user

/api/v8/users/{username}

Usage and SDK Samples

curl -X PUT -H "Accept: application/json" -H "Authorization: Basic [[basicHash]]" "https://localhost/api/v8/users/{username}"

import com.cloudera.director.client.common.*;
import com.cloudera.director.client.common.auth.*;
import com.cloudera.director.client.common.model.*;
import com.cloudera.director.client.common.api.UsersApi;

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

public class UsersApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        UsersApi apiInstance = new UsersApi();
        String username = username_example; // String | 
        User user = ; // User | 
        try {
            apiInstance.update(username, user);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersApi#update");
            e.printStackTrace();
        }
    }
}

import com.cloudera.director.client.common.api.UsersApi;

public class UsersApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *username = username_example; // 
User *user = ; // 

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

// Update an existing user
[apiInstance updateWith:username
    user:user
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaAltusDirectorApi = require('cloudera_altus_director_api');
var defaultClient = ClouderaAltusDirectorApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new ClouderaAltusDirectorApi.UsersApi()

var username = username_example; // {String} 

var user = ; // {User} 


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

using System;
using System.Diagnostics;
using cloudera.director.Api;
using cloudera.director.Client;
using cloudera.director.Model;

namespace Example
{
    public class updateExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new UsersApi();
            var username = username_example;  // String | 
            var user = new User(); // User | 

            try
            {
                // Update an existing user
                apiInstance.update(username, user);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling UsersApi.update: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\UsersApi();
$username = username_example; // String | 
$user = ; // User | 

try {
    $api_instance->update($username, $user);
} catch (Exception $e) {
    echo 'Exception when calling UsersApi->update: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::UsersApi->new();
my $username = username_example; # String | 
my $user = WWW::SwaggerClient::Object::User->new(); # User | 

eval { 
    $api_instance->update(username => $username, user => $user);
};
if ($@) {
    warn "Exception when calling UsersApi->update: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.UsersApi()
username = username_example # String | 
user =  # User | 

try: 
    # Update an existing user
    api_instance.update(username, user)
except ApiException as e:
    print("Exception when calling UsersApi->update: %s\n" % e)

Parameters

Path parameters

Name	Description
username*	String Required

Body parameters

Name	Description
user *

Responses

Status: 202 - Updated user accepted

Status: 400 - Validation error or rename not allowed

Status: 404 - User not found

updatePassword

Update the password of an existing user

/api/v8/users/{username}/password

Usage and SDK Samples

curl -X PUT -H "Accept: application/json" -H "Authorization: Basic [[basicHash]]" "https://localhost/api/v8/users/{username}/password"

import com.cloudera.director.client.common.*;
import com.cloudera.director.client.common.auth.*;
import com.cloudera.director.client.common.model.*;
import com.cloudera.director.client.common.api.UsersApi;

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

public class UsersApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        UsersApi apiInstance = new UsersApi();
        String username = username_example; // String | 
        PasswordChange passwords = ; // PasswordChange | 
        try {
            apiInstance.updatePassword(username, passwords);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersApi#updatePassword");
            e.printStackTrace();
        }
    }
}

import com.cloudera.director.client.common.api.UsersApi;

public class UsersApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *username = username_example; // 
PasswordChange *passwords = ; // 

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

// Update the password of an existing user
[apiInstance updatePasswordWith:username
    passwords:passwords
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaAltusDirectorApi = require('cloudera_altus_director_api');
var defaultClient = ClouderaAltusDirectorApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new ClouderaAltusDirectorApi.UsersApi()

var username = username_example; // {String} 

var passwords = ; // {PasswordChange} 


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

using System;
using System.Diagnostics;
using cloudera.director.Api;
using cloudera.director.Client;
using cloudera.director.Model;

namespace Example
{
    public class updatePasswordExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new UsersApi();
            var username = username_example;  // String | 
            var passwords = new PasswordChange(); // PasswordChange | 

            try
            {
                // Update the password of an existing user
                apiInstance.updatePassword(username, passwords);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling UsersApi.updatePassword: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\UsersApi();
$username = username_example; // String | 
$passwords = ; // PasswordChange | 

try {
    $api_instance->updatePassword($username, $passwords);
} catch (Exception $e) {
    echo 'Exception when calling UsersApi->updatePassword: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::UsersApi->new();
my $username = username_example; # String | 
my $passwords = WWW::SwaggerClient::Object::PasswordChange->new(); # PasswordChange | 

eval { 
    $api_instance->updatePassword(username => $username, passwords => $passwords);
};
if ($@) {
    warn "Exception when calling UsersApi->updatePassword: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.UsersApi()
username = username_example # String | 
passwords =  # PasswordChange | 

try: 
    # Update the password of an existing user
    api_instance.update_password(username, passwords)
except ApiException as e:
    print("Exception when calling UsersApi->updatePassword: %s\n" % e)

Parameters

Path parameters

Name	Description
username*	String Required

Body parameters

Name	Description
passwords *

Responses

Status: 202 - Updated password accepted

Status: 400 - Validation error or old password is missing or incorrect

Status: 403 - May only change own password

Status: 404 - User not found

Generated 2019-04-03T15:10:11.737-04:00

Cloudera Altus Director API

API and SDK Documentation

Authentication

login

Usage and SDK Samples

Parameters

Responses

Status: 200 - Login successful

Status: 400 - Invalid login

Status: 401 - Login failed

logout

Usage and SDK Samples

Parameters

Responses

Status: 200 - Logout successful

Status: 401 - Not logged in

Clusters

collectDiagnosticData

Usage and SDK Samples

Parameters

Responses

Status: 202 - Accepted

Status: 404 - Entity not found

Status: 409 - Cluster is in transition

Status: 412 - Deployment is not available

create

Usage and SDK Samples

Parameters

Responses

Status: 201 - Cluster template accepted

Status: 302 - Cluster already exists

Status: 400 - Invalid cluster template

delete

Usage and SDK Samples

Parameters

Responses

Status: 204 - Delete request accepted

Status: 404 - Entity not found

get

Usage and SDK Samples

Parameters

Responses

Status: 200 - OK

Status: 204 - Cluster is in transition or failed stage

Status: 404 - Entity not found

getMetrics

Usage and SDK Samples

Parameters

Responses

Status: 200 - OK

Status: 204 - Cluster is in transition or a failed stage

Status: 404 - Entity not found

getStatus

Usage and SDK Samples

Parameters

Responses

Status: 200 - OK

Status: 404 - Entity not found

getTemplateRedacted

Usage and SDK Samples

Parameters

Responses

Status: 200 - OK

Status: 404 - Entity not found

list

Usage and SDK Samples

Parameters

Responses

Status: 200 - OK

Status: 404 - Entity not found

update

Usage and SDK Samples

Parameters

Responses

Status: 202 - Cluster update accepted

Status: 400 - Cluster update not supported

Status: 404 - Not found

Status: 409 - Cluster is in a non-updatable state

DatabaseServers

create