Kafka Connect REST API

Default

createConnector

Create a new connector

/connectors

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"//connectors"

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

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

public class DefaultApiExample {

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

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

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

CreateConnectorRequest *body = ; //  (optional)

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

// Create a new connector
[apiInstance createConnectorWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var KafkaConnectRestApi = require('kafka_connect_rest_api');

var api = new KafkaConnectRestApi.DefaultApi()
var opts = { 
  'body':  // {{CreateConnectorRequest}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.createConnector(opts, callback);

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

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

            var apiInstance = new DefaultApi();
            var body = new CreateConnectorRequest(); // CreateConnectorRequest |  (optional) 

            try
            {
                // Create a new connector
                apiInstance.createConnector(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.createConnector: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiDefaultApi();
$body = ; // CreateConnectorRequest | 

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

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

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

eval { 
    $api_instance->createConnector(body => $body);
};
if ($@) {
    warn "Exception when calling DefaultApi->createConnector: $@\n";
}

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

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

try: 
    # Create a new connector
    api_instance.create_connector(body=body)
except ApiException as e:
    print("Exception when calling DefaultApi->createConnector: %s\n" % e)

Parameters

Body parameters

Name	Description
body

Responses

Status: default - default response

destroyConnector

Delete the specified connector

/connectors/{connector}

Usage and SDK Samples

curl -X DELETE\
-H "Accept: application/json"\
"//connectors/{connector}"

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

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String connector = connector_example; // String | 
        try {
            apiInstance.destroyConnector(connector);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#destroyConnector");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String connector = connector_example; // String | 
        try {
            apiInstance.destroyConnector(connector);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#destroyConnector");
            e.printStackTrace();
        }
    }
}

String *connector = connector_example; // 

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

// Delete the specified connector
[apiInstance destroyConnectorWith:connector
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var KafkaConnectRestApi = require('kafka_connect_rest_api');

var api = new KafkaConnectRestApi.DefaultApi()
var connector = connector_example; // {{String}} 

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

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

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

            var apiInstance = new DefaultApi();
            var connector = connector_example;  // String | 

            try
            {
                // Delete the specified connector
                apiInstance.destroyConnector(connector);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.destroyConnector: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiDefaultApi();
$connector = connector_example; // String | 

try {
    $api_instance->destroyConnector($connector);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->destroyConnector: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $connector = connector_example; # String | 

eval { 
    $api_instance->destroyConnector(connector => $connector);
};
if ($@) {
    warn "Exception when calling DefaultApi->destroyConnector: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
connector = connector_example # String | 

try: 
    # Delete the specified connector
    api_instance.destroy_connector(connector)
except ApiException as e:
    print("Exception when calling DefaultApi->destroyConnector: %s\n" % e)

Parameters

Path parameters

Name	Description
connector*	String Required

Responses

Status: default - default response

getConnector

Get the details for the specified connector

/connectors/{connector}

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"//connectors/{connector}"

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

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String connector = connector_example; // String | 
        try {
            ConnectorInfo result = apiInstance.getConnector(connector);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getConnector");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String connector = connector_example; // String | 
        try {
            ConnectorInfo result = apiInstance.getConnector(connector);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getConnector");
            e.printStackTrace();
        }
    }
}

String *connector = connector_example; // 

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

// Get the details for the specified connector
[apiInstance getConnectorWith:connector
              completionHandler: ^(ConnectorInfo output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var KafkaConnectRestApi = require('kafka_connect_rest_api');

var api = new KafkaConnectRestApi.DefaultApi()
var connector = connector_example; // {{String}} 

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

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

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

            var apiInstance = new DefaultApi();
            var connector = connector_example;  // String | 

            try
            {
                // Get the details for the specified connector
                ConnectorInfo result = apiInstance.getConnector(connector);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.getConnector: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiDefaultApi();
$connector = connector_example; // String | 

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

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $connector = connector_example; # String | 

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

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

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
connector = connector_example # String | 

try: 
    # Get the details for the specified connector
    api_response = api_instance.get_connector(connector)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getConnector: %s\n" % e)

Parameters

Path parameters

Name	Description
connector*	String Required

Responses

Status: default - default response

Schema

getConnectorActiveTopics

Get the list of topics actively used by the specified connector

/connectors/{connector}/topics

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"//connectors/{connector}/topics"

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

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String connector = connector_example; // String | 
        try {
            apiInstance.getConnectorActiveTopics(connector);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getConnectorActiveTopics");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String connector = connector_example; // String | 
        try {
            apiInstance.getConnectorActiveTopics(connector);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getConnectorActiveTopics");
            e.printStackTrace();
        }
    }
}

String *connector = connector_example; // 

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

// Get the list of topics actively used by the specified connector
[apiInstance getConnectorActiveTopicsWith:connector
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var KafkaConnectRestApi = require('kafka_connect_rest_api');

var api = new KafkaConnectRestApi.DefaultApi()
var connector = connector_example; // {{String}} 

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

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

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

            var apiInstance = new DefaultApi();
            var connector = connector_example;  // String | 

            try
            {
                // Get the list of topics actively used by the specified connector
                apiInstance.getConnectorActiveTopics(connector);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.getConnectorActiveTopics: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiDefaultApi();
$connector = connector_example; // String | 

try {
    $api_instance->getConnectorActiveTopics($connector);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getConnectorActiveTopics: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $connector = connector_example; # String | 

eval { 
    $api_instance->getConnectorActiveTopics(connector => $connector);
};
if ($@) {
    warn "Exception when calling DefaultApi->getConnectorActiveTopics: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
connector = connector_example # String | 

try: 
    # Get the list of topics actively used by the specified connector
    api_instance.get_connector_active_topics(connector)
except ApiException as e:
    print("Exception when calling DefaultApi->getConnectorActiveTopics: %s\n" % e)

Parameters

Path parameters

Name	Description
connector*	String Required

Responses

Status: default - default response

getConnectorConfig

Get the configuration for the specified connector

/connectors/{connector}/config

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"//connectors/{connector}/config"

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

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String connector = connector_example; // String | 
        try {
            map['String', 'String'] result = apiInstance.getConnectorConfig(connector);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getConnectorConfig");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String connector = connector_example; // String | 
        try {
            map['String', 'String'] result = apiInstance.getConnectorConfig(connector);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getConnectorConfig");
            e.printStackTrace();
        }
    }
}

String *connector = connector_example; // 

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

// Get the configuration for the specified connector
[apiInstance getConnectorConfigWith:connector
              completionHandler: ^(map['String', 'String'] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var KafkaConnectRestApi = require('kafka_connect_rest_api');

var api = new KafkaConnectRestApi.DefaultApi()
var connector = connector_example; // {{String}} 

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

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

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

            var apiInstance = new DefaultApi();
            var connector = connector_example;  // String | 

            try
            {
                // Get the configuration for the specified connector
                map['String', 'String'] result = apiInstance.getConnectorConfig(connector);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.getConnectorConfig: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiDefaultApi();
$connector = connector_example; // String | 

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

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $connector = connector_example; # String | 

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

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

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
connector = connector_example # String | 

try: 
    # Get the configuration for the specified connector
    api_response = api_instance.get_connector_config(connector)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getConnectorConfig: %s\n" % e)

Parameters

Path parameters

Name	Description
connector*	String Required

Responses

Status: default - default response

Schema

getConnectorConfigDef

Get the configuration definition for the specified pluginName

/connector-plugins/{pluginName}/config

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"//connector-plugins/{pluginName}/config"

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

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String pluginName = pluginName_example; // String | 
        try {
            array[ConfigKeyInfo] result = apiInstance.getConnectorConfigDef(pluginName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getConnectorConfigDef");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String pluginName = pluginName_example; // String | 
        try {
            array[ConfigKeyInfo] result = apiInstance.getConnectorConfigDef(pluginName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getConnectorConfigDef");
            e.printStackTrace();
        }
    }
}

String *pluginName = pluginName_example; // 

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

// Get the configuration definition for the specified pluginName
[apiInstance getConnectorConfigDefWith:pluginName
              completionHandler: ^(array[ConfigKeyInfo] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var KafkaConnectRestApi = require('kafka_connect_rest_api');

var api = new KafkaConnectRestApi.DefaultApi()
var pluginName = pluginName_example; // {{String}} 

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

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

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

            var apiInstance = new DefaultApi();
            var pluginName = pluginName_example;  // String | 

            try
            {
                // Get the configuration definition for the specified pluginName
                array[ConfigKeyInfo] result = apiInstance.getConnectorConfigDef(pluginName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.getConnectorConfigDef: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiDefaultApi();
$pluginName = pluginName_example; // String | 

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

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $pluginName = pluginName_example; # String | 

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

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

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
pluginName = pluginName_example # String | 

try: 
    # Get the configuration definition for the specified pluginName
    api_response = api_instance.get_connector_config_def(pluginName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getConnectorConfigDef: %s\n" % e)

Parameters

Path parameters

Name	Description
pluginName*	String Required

Responses

Status: default - default response

Schema

getConnectorStatus

Get the status for the specified connector

/connectors/{connector}/status

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"//connectors/{connector}/status"

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

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String connector = connector_example; // String | 
        try {
            ConnectorStateInfo result = apiInstance.getConnectorStatus(connector);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getConnectorStatus");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String connector = connector_example; // String | 
        try {
            ConnectorStateInfo result = apiInstance.getConnectorStatus(connector);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getConnectorStatus");
            e.printStackTrace();
        }
    }
}

String *connector = connector_example; // 

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

// Get the status for the specified connector
[apiInstance getConnectorStatusWith:connector
              completionHandler: ^(ConnectorStateInfo output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var KafkaConnectRestApi = require('kafka_connect_rest_api');

var api = new KafkaConnectRestApi.DefaultApi()
var connector = connector_example; // {{String}} 

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

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

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

            var apiInstance = new DefaultApi();
            var connector = connector_example;  // String | 

            try
            {
                // Get the status for the specified connector
                ConnectorStateInfo result = apiInstance.getConnectorStatus(connector);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.getConnectorStatus: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiDefaultApi();
$connector = connector_example; // String | 

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

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $connector = connector_example; # String | 

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

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

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
connector = connector_example # String | 

try: 
    # Get the status for the specified connector
    api_response = api_instance.get_connector_status(connector)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getConnectorStatus: %s\n" % e)

Parameters

Path parameters

Name	Description
connector*	String Required

Responses

Status: default - default response

Schema

getLogger

Get the log level for the specified logger

/admin/loggers/{logger}

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"//admin/loggers/{logger}"

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

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String logger = logger_example; // String | 
        try {
            apiInstance.getLogger(logger);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getLogger");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String logger = logger_example; // String | 
        try {
            apiInstance.getLogger(logger);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getLogger");
            e.printStackTrace();
        }
    }
}

String *logger = logger_example; // 

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

// Get the log level for the specified logger
[apiInstance getLoggerWith:logger
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var KafkaConnectRestApi = require('kafka_connect_rest_api');

var api = new KafkaConnectRestApi.DefaultApi()
var logger = logger_example; // {{String}} 

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

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

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

            var apiInstance = new DefaultApi();
            var logger = logger_example;  // String | 

            try
            {
                // Get the log level for the specified logger
                apiInstance.getLogger(logger);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.getLogger: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiDefaultApi();
$logger = logger_example; // String | 

try {
    $api_instance->getLogger($logger);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getLogger: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $logger = logger_example; # String | 

eval { 
    $api_instance->getLogger(logger => $logger);
};
if ($@) {
    warn "Exception when calling DefaultApi->getLogger: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
logger = logger_example # String | 

try: 
    # Get the log level for the specified logger
    api_instance.get_logger(logger)
except ApiException as e:
    print("Exception when calling DefaultApi->getLogger: %s\n" % e)

Parameters

Path parameters

Name	Description
logger*	String Required

Responses

Status: default - default response

getTaskConfigs

List all tasks for the specified connector

/connectors/{connector}/tasks

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"//connectors/{connector}/tasks"

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

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String connector = connector_example; // String | 
        try {
            array[TaskInfo] result = apiInstance.getTaskConfigs(connector);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getTaskConfigs");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String connector = connector_example; // String | 
        try {
            array[TaskInfo] result = apiInstance.getTaskConfigs(connector);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getTaskConfigs");
            e.printStackTrace();
        }
    }
}

String *connector = connector_example; // 

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

// List all tasks for the specified connector
[apiInstance getTaskConfigsWith:connector
              completionHandler: ^(array[TaskInfo] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var KafkaConnectRestApi = require('kafka_connect_rest_api');

var api = new KafkaConnectRestApi.DefaultApi()
var connector = connector_example; // {{String}} 

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

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

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

            var apiInstance = new DefaultApi();
            var connector = connector_example;  // String | 

            try
            {
                // List all tasks for the specified connector
                array[TaskInfo] result = apiInstance.getTaskConfigs(connector);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.getTaskConfigs: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiDefaultApi();
$connector = connector_example; // String | 

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

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $connector = connector_example; # String | 

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

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

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
connector = connector_example # String | 

try: 
    # List all tasks for the specified connector
    api_response = api_instance.get_task_configs(connector)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getTaskConfigs: %s\n" % e)

Parameters

Path parameters

Name	Description
connector*	String Required

Responses

Status: default - default response

Schema

getTaskStatus

Get the state of the specified task for the specified connector

/connectors/{connector}/tasks/{task}/status

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"//connectors/{connector}/tasks/{task}/status"

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

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String connector = connector_example; // String | 
        Integer task = 56; // Integer | 
        try {
            TaskState result = apiInstance.getTaskStatus(connector, task);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getTaskStatus");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String connector = connector_example; // String | 
        Integer task = 56; // Integer | 
        try {
            TaskState result = apiInstance.getTaskStatus(connector, task);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getTaskStatus");
            e.printStackTrace();
        }
    }
}

String *connector = connector_example; // 
Integer *task = 56; // 

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

// Get the state of the specified task for the specified connector
[apiInstance getTaskStatusWith:connector
    task:task
              completionHandler: ^(TaskState output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var KafkaConnectRestApi = require('kafka_connect_rest_api');

var api = new KafkaConnectRestApi.DefaultApi()
var connector = connector_example; // {{String}} 
var task = 56; // {{Integer}} 

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

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

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

            var apiInstance = new DefaultApi();
            var connector = connector_example;  // String | 
            var task = 56;  // Integer | 

            try
            {
                // Get the state of the specified task for the specified connector
                TaskState result = apiInstance.getTaskStatus(connector, task);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.getTaskStatus: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiDefaultApi();
$connector = connector_example; // String | 
$task = 56; // Integer | 

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

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $connector = connector_example; # String | 
my $task = 56; # Integer | 

eval { 
    my $result = $api_instance->getTaskStatus(connector => $connector, task => $task);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getTaskStatus: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
connector = connector_example # String | 
task = 56 # Integer | 

try: 
    # Get the state of the specified task for the specified connector
    api_response = api_instance.get_task_status(connector, task)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getTaskStatus: %s\n" % e)

Parameters

Path parameters

Name	Description
connector*	String Required
task*	Integer (int32) Required

Responses

Status: default - default response

Schema

getTasksConfig

Get the configuration of all tasks for the specified connector

/connectors/{connector}/tasks-config

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"//connectors/{connector}/tasks-config"

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

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String connector = connector_example; // String | 
        try {
            map['String', map['String', 'String']] result = apiInstance.getTasksConfig(connector);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getTasksConfig");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String connector = connector_example; // String | 
        try {
            map['String', map['String', 'String']] result = apiInstance.getTasksConfig(connector);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getTasksConfig");
            e.printStackTrace();
        }
    }
}

String *connector = connector_example; // 

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

// Get the configuration of all tasks for the specified connector
[apiInstance getTasksConfigWith:connector
              completionHandler: ^(map['String', map['String', 'String']] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var KafkaConnectRestApi = require('kafka_connect_rest_api');

var api = new KafkaConnectRestApi.DefaultApi()
var connector = connector_example; // {{String}} 

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

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

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

            var apiInstance = new DefaultApi();
            var connector = connector_example;  // String | 

            try
            {
                // Get the configuration of all tasks for the specified connector
                map['String', map['String', 'String']] result = apiInstance.getTasksConfig(connector);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.getTasksConfig: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiDefaultApi();
$connector = connector_example; // String | 

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

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $connector = connector_example; # String | 

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

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

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
connector = connector_example # String | 

try: 
    # Get the configuration of all tasks for the specified connector
    api_response = api_instance.get_tasks_config(connector)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getTasksConfig: %s\n" % e)

Parameters

Path parameters

Name	Description
connector*	String Required

Responses

Status: default - default response

Schema

listConnectorPlugins

List all connector plugins installed

/connector-plugins

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"//connector-plugins?connectorsOnly="

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

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        Boolean connectorsOnly = true; // Boolean | Whether to list only connectors instead of all plugins
        try {
            array[PluginInfo] result = apiInstance.listConnectorPlugins(connectorsOnly);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#listConnectorPlugins");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        Boolean connectorsOnly = true; // Boolean | Whether to list only connectors instead of all plugins
        try {
            array[PluginInfo] result = apiInstance.listConnectorPlugins(connectorsOnly);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#listConnectorPlugins");
            e.printStackTrace();
        }
    }
}

Boolean *connectorsOnly = true; // Whether to list only connectors instead of all plugins (optional) (default to true)

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

// List all connector plugins installed
[apiInstance listConnectorPluginsWith:connectorsOnly
              completionHandler: ^(array[PluginInfo] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var KafkaConnectRestApi = require('kafka_connect_rest_api');

var api = new KafkaConnectRestApi.DefaultApi()
var opts = { 
  'connectorsOnly': true // {{Boolean}} Whether to list only connectors instead of all plugins
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.listConnectorPlugins(opts, callback);

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

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

            var apiInstance = new DefaultApi();
            var connectorsOnly = true;  // Boolean | Whether to list only connectors instead of all plugins (optional)  (default to true)

            try
            {
                // List all connector plugins installed
                array[PluginInfo] result = apiInstance.listConnectorPlugins(connectorsOnly);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.listConnectorPlugins: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiDefaultApi();
$connectorsOnly = true; // Boolean | Whether to list only connectors instead of all plugins

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

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $connectorsOnly = true; # Boolean | Whether to list only connectors instead of all plugins

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

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

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
connectorsOnly = true # Boolean | Whether to list only connectors instead of all plugins (optional) (default to true)

try: 
    # List all connector plugins installed
    api_response = api_instance.list_connector_plugins(connectorsOnly=connectorsOnly)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->listConnectorPlugins: %s\n" % e)

Parameters

Query parameters

Name	Description
connectorsOnly	Boolean Whether to list only connectors instead of all plugins

Responses

Status: default - default response

Schema

listConnectors

List all active connectors

/connectors

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"//connectors"

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

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

public class DefaultApiExample {

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

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

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


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

// List all active connectors
[apiInstance listConnectorsWithCompletionHandler: 
              ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var KafkaConnectRestApi = require('kafka_connect_rest_api');

var api = new KafkaConnectRestApi.DefaultApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.listConnectors(callback);

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

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

            var apiInstance = new DefaultApi();

            try
            {
                // List all active connectors
                apiInstance.listConnectors();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.listConnectors: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

eval { 
    $api_instance->listConnectors();
};
if ($@) {
    warn "Exception when calling DefaultApi->listConnectors: $@\n";
}

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

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

try: 
    # List all active connectors
    api_instance.list_connectors()
except ApiException as e:
    print("Exception when calling DefaultApi->listConnectors: %s\n" % e)

Parameters

Responses

Status: default - default response

listLoggers

List the current loggers that have their levels explicitly set and their log levels

/admin/loggers

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"//admin/loggers"

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

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

public class DefaultApiExample {

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

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

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


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

// List the current loggers that have their levels explicitly set and their log levels
[apiInstance listLoggersWithCompletionHandler: 
              ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var KafkaConnectRestApi = require('kafka_connect_rest_api');

var api = new KafkaConnectRestApi.DefaultApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.listLoggers(callback);

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

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

            var apiInstance = new DefaultApi();

            try
            {
                // List the current loggers that have their levels explicitly set and their log levels
                apiInstance.listLoggers();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.listLoggers: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

eval { 
    $api_instance->listLoggers();
};
if ($@) {
    warn "Exception when calling DefaultApi->listLoggers: $@\n";
}

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

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

try: 
    # List the current loggers that have their levels explicitly set and their log levels
    api_instance.list_loggers()
except ApiException as e:
    print("Exception when calling DefaultApi->listLoggers: %s\n" % e)

Parameters

Responses

Status: default - default response

pauseConnector

Pause the specified connector

This operation is idempotent and has no effects if the connector is already paused

/connectors/{connector}/pause

Usage and SDK Samples

curl -X PUT\
-H "Accept: application/json"\
"//connectors/{connector}/pause"

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

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String connector = connector_example; // String | 
        try {
            apiInstance.pauseConnector(connector);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#pauseConnector");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String connector = connector_example; // String | 
        try {
            apiInstance.pauseConnector(connector);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#pauseConnector");
            e.printStackTrace();
        }
    }
}

String *connector = connector_example; // 

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

// Pause the specified connector
[apiInstance pauseConnectorWith:connector
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var KafkaConnectRestApi = require('kafka_connect_rest_api');

var api = new KafkaConnectRestApi.DefaultApi()
var connector = connector_example; // {{String}} 

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

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

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

            var apiInstance = new DefaultApi();
            var connector = connector_example;  // String | 

            try
            {
                // Pause the specified connector
                apiInstance.pauseConnector(connector);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.pauseConnector: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiDefaultApi();
$connector = connector_example; // String | 

try {
    $api_instance->pauseConnector($connector);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->pauseConnector: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $connector = connector_example; # String | 

eval { 
    $api_instance->pauseConnector(connector => $connector);
};
if ($@) {
    warn "Exception when calling DefaultApi->pauseConnector: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
connector = connector_example # String | 

try: 
    # Pause the specified connector
    api_instance.pause_connector(connector)
except ApiException as e:
    print("Exception when calling DefaultApi->pauseConnector: %s\n" % e)

Parameters

Path parameters

Name	Description
connector*	String Required

Responses

Status: default - default response

putConnectorConfig

Create or reconfigure the specified connector

/connectors/{connector}/config

Usage and SDK Samples

curl -X PUT\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"//connectors/{connector}/config"

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

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String connector = connector_example; // String | 
        map[String, String] body = ; // map[String, String] | 
        try {
            apiInstance.putConnectorConfig(connector, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#putConnectorConfig");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String connector = connector_example; // String | 
        map[String, String] body = ; // map[String, String] | 
        try {
            apiInstance.putConnectorConfig(connector, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#putConnectorConfig");
            e.printStackTrace();
        }
    }
}

String *connector = connector_example; // 
map[String, String] *body = ; //  (optional)

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

// Create or reconfigure the specified connector
[apiInstance putConnectorConfigWith:connector
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var KafkaConnectRestApi = require('kafka_connect_rest_api');

var api = new KafkaConnectRestApi.DefaultApi()
var connector = connector_example; // {{String}} 
var opts = { 
  'body':  // {{map[String, String]}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.putConnectorConfig(connector, opts, callback);

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

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

            var apiInstance = new DefaultApi();
            var connector = connector_example;  // String | 
            var body = new map[String, String](); // map[String, String] |  (optional) 

            try
            {
                // Create or reconfigure the specified connector
                apiInstance.putConnectorConfig(connector, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.putConnectorConfig: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiDefaultApi();
$connector = connector_example; // String | 
$body = ; // map[String, String] | 

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

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $connector = connector_example; # String | 
my $body = WWW::SwaggerClient::Object::map[String, String]->new(); # map[String, String] | 

eval { 
    $api_instance->putConnectorConfig(connector => $connector, body => $body);
};
if ($@) {
    warn "Exception when calling DefaultApi->putConnectorConfig: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
connector = connector_example # String | 
body =  # map[String, String] |  (optional)

try: 
    # Create or reconfigure the specified connector
    api_instance.put_connector_config(connector, body=body)
except ApiException as e:
    print("Exception when calling DefaultApi->putConnectorConfig: %s\n" % e)

Parameters

Path parameters

Name	Description
connector*	String Required

Body parameters

Name	Description
body

Responses

Status: default - default response

resetConnectorActiveTopics

Reset the list of topics actively used by the specified connector

/connectors/{connector}/topics/reset

Usage and SDK Samples

curl -X PUT\
-H "Accept: application/json"\
"//connectors/{connector}/topics/reset"

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

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String connector = connector_example; // String | 
        try {
            apiInstance.resetConnectorActiveTopics(connector);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#resetConnectorActiveTopics");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String connector = connector_example; // String | 
        try {
            apiInstance.resetConnectorActiveTopics(connector);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#resetConnectorActiveTopics");
            e.printStackTrace();
        }
    }
}

String *connector = connector_example; // 

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

// Reset the list of topics actively used by the specified connector
[apiInstance resetConnectorActiveTopicsWith:connector
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var KafkaConnectRestApi = require('kafka_connect_rest_api');

var api = new KafkaConnectRestApi.DefaultApi()
var connector = connector_example; // {{String}} 

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

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

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

            var apiInstance = new DefaultApi();
            var connector = connector_example;  // String | 

            try
            {
                // Reset the list of topics actively used by the specified connector
                apiInstance.resetConnectorActiveTopics(connector);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.resetConnectorActiveTopics: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiDefaultApi();
$connector = connector_example; // String | 

try {
    $api_instance->resetConnectorActiveTopics($connector);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->resetConnectorActiveTopics: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $connector = connector_example; # String | 

eval { 
    $api_instance->resetConnectorActiveTopics(connector => $connector);
};
if ($@) {
    warn "Exception when calling DefaultApi->resetConnectorActiveTopics: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
connector = connector_example # String | 

try: 
    # Reset the list of topics actively used by the specified connector
    api_instance.reset_connector_active_topics(connector)
except ApiException as e:
    print("Exception when calling DefaultApi->resetConnectorActiveTopics: %s\n" % e)

Parameters

Path parameters

Name	Description
connector*	String Required

Responses

Status: default - default response

restartConnector

Restart the specified connector

/connectors/{connector}/restart

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
"//connectors/{connector}/restart?includeTasks=&onlyFailed="

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

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String connector = connector_example; // String | 
        Boolean includeTasks = true; // Boolean | Whether to also restart tasks
        Boolean onlyFailed = true; // Boolean | Whether to only restart failed tasks/connectors
        try {
            apiInstance.restartConnector(connector, includeTasks, onlyFailed);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#restartConnector");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String connector = connector_example; // String | 
        Boolean includeTasks = true; // Boolean | Whether to also restart tasks
        Boolean onlyFailed = true; // Boolean | Whether to only restart failed tasks/connectors
        try {
            apiInstance.restartConnector(connector, includeTasks, onlyFailed);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#restartConnector");
            e.printStackTrace();
        }
    }
}

String *connector = connector_example; // 
Boolean *includeTasks = true; // Whether to also restart tasks (optional) (default to false)
Boolean *onlyFailed = true; // Whether to only restart failed tasks/connectors (optional) (default to false)

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

// Restart the specified connector
[apiInstance restartConnectorWith:connector
    includeTasks:includeTasks
    onlyFailed:onlyFailed
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var KafkaConnectRestApi = require('kafka_connect_rest_api');

var api = new KafkaConnectRestApi.DefaultApi()
var connector = connector_example; // {{String}} 
var opts = { 
  'includeTasks': true, // {{Boolean}} Whether to also restart tasks
  'onlyFailed': true // {{Boolean}} Whether to only restart failed tasks/connectors
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.restartConnector(connector, opts, callback);

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

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

            var apiInstance = new DefaultApi();
            var connector = connector_example;  // String | 
            var includeTasks = true;  // Boolean | Whether to also restart tasks (optional)  (default to false)
            var onlyFailed = true;  // Boolean | Whether to only restart failed tasks/connectors (optional)  (default to false)

            try
            {
                // Restart the specified connector
                apiInstance.restartConnector(connector, includeTasks, onlyFailed);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.restartConnector: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiDefaultApi();
$connector = connector_example; // String | 
$includeTasks = true; // Boolean | Whether to also restart tasks
$onlyFailed = true; // Boolean | Whether to only restart failed tasks/connectors

try {
    $api_instance->restartConnector($connector, $includeTasks, $onlyFailed);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->restartConnector: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $connector = connector_example; # String | 
my $includeTasks = true; # Boolean | Whether to also restart tasks
my $onlyFailed = true; # Boolean | Whether to only restart failed tasks/connectors

eval { 
    $api_instance->restartConnector(connector => $connector, includeTasks => $includeTasks, onlyFailed => $onlyFailed);
};
if ($@) {
    warn "Exception when calling DefaultApi->restartConnector: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
connector = connector_example # String | 
includeTasks = true # Boolean | Whether to also restart tasks (optional) (default to false)
onlyFailed = true # Boolean | Whether to only restart failed tasks/connectors (optional) (default to false)

try: 
    # Restart the specified connector
    api_instance.restart_connector(connector, includeTasks=includeTasks, onlyFailed=onlyFailed)
except ApiException as e:
    print("Exception when calling DefaultApi->restartConnector: %s\n" % e)

Parameters

Path parameters

Name	Description
connector*	String Required

Query parameters

Name	Description
includeTasks	Boolean Whether to also restart tasks
onlyFailed	Boolean Whether to only restart failed tasks/connectors

Responses

Status: default - default response

restartTask

Restart the specified task for the specified connector

/connectors/{connector}/tasks/{task}/restart

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
"//connectors/{connector}/tasks/{task}/restart"

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

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String connector = connector_example; // String | 
        Integer task = 56; // Integer | 
        try {
            apiInstance.restartTask(connector, task);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#restartTask");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String connector = connector_example; // String | 
        Integer task = 56; // Integer | 
        try {
            apiInstance.restartTask(connector, task);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#restartTask");
            e.printStackTrace();
        }
    }
}

String *connector = connector_example; // 
Integer *task = 56; // 

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

// Restart the specified task for the specified connector
[apiInstance restartTaskWith:connector
    task:task
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var KafkaConnectRestApi = require('kafka_connect_rest_api');

var api = new KafkaConnectRestApi.DefaultApi()
var connector = connector_example; // {{String}} 
var task = 56; // {{Integer}} 

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

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

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

            var apiInstance = new DefaultApi();
            var connector = connector_example;  // String | 
            var task = 56;  // Integer | 

            try
            {
                // Restart the specified task for the specified connector
                apiInstance.restartTask(connector, task);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.restartTask: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiDefaultApi();
$connector = connector_example; // String | 
$task = 56; // Integer | 

try {
    $api_instance->restartTask($connector, $task);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->restartTask: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $connector = connector_example; # String | 
my $task = 56; # Integer | 

eval { 
    $api_instance->restartTask(connector => $connector, task => $task);
};
if ($@) {
    warn "Exception when calling DefaultApi->restartTask: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
connector = connector_example # String | 
task = 56 # Integer | 

try: 
    # Restart the specified task for the specified connector
    api_instance.restart_task(connector, task)
except ApiException as e:
    print("Exception when calling DefaultApi->restartTask: %s\n" % e)

Parameters

Path parameters

Name	Description
connector*	String Required
task*	Integer (int32) Required

Responses

Status: default - default response

resumeConnector

Resume the specified connector

This operation is idempotent and has no effects if the connector is already running

/connectors/{connector}/resume

Usage and SDK Samples

curl -X PUT\
-H "Accept: application/json"\
"//connectors/{connector}/resume"

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

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String connector = connector_example; // String | 
        try {
            apiInstance.resumeConnector(connector);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#resumeConnector");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String connector = connector_example; // String | 
        try {
            apiInstance.resumeConnector(connector);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#resumeConnector");
            e.printStackTrace();
        }
    }
}

String *connector = connector_example; // 

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

// Resume the specified connector
[apiInstance resumeConnectorWith:connector
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var KafkaConnectRestApi = require('kafka_connect_rest_api');

var api = new KafkaConnectRestApi.DefaultApi()
var connector = connector_example; // {{String}} 

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

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

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

            var apiInstance = new DefaultApi();
            var connector = connector_example;  // String | 

            try
            {
                // Resume the specified connector
                apiInstance.resumeConnector(connector);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.resumeConnector: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiDefaultApi();
$connector = connector_example; // String | 

try {
    $api_instance->resumeConnector($connector);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->resumeConnector: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $connector = connector_example; # String | 

eval { 
    $api_instance->resumeConnector(connector => $connector);
};
if ($@) {
    warn "Exception when calling DefaultApi->resumeConnector: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
connector = connector_example # String | 

try: 
    # Resume the specified connector
    api_instance.resume_connector(connector)
except ApiException as e:
    print("Exception when calling DefaultApi->resumeConnector: %s\n" % e)

Parameters

Path parameters

Name	Description
connector*	String Required

Responses

Status: default - default response

serverInfo

Get details about this Connect worker and the id of the Kafka cluster it is connected to

Usage and SDK Samples

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

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

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

public class DefaultApiExample {

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

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

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


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

// Get details about this Connect worker and the id of the Kafka cluster it is connected to
[apiInstance serverInfoWithCompletionHandler: 
              ^(ServerInfo output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var KafkaConnectRestApi = require('kafka_connect_rest_api');

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

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

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

            var apiInstance = new DefaultApi();

            try
            {
                // Get details about this Connect worker and the id of the Kafka cluster it is connected to
                ServerInfo result = apiInstance.serverInfo();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.serverInfo: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

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

try: 
    # Get details about this Connect worker and the id of the Kafka cluster it is connected to
    api_response = api_instance.server_info()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->serverInfo: %s\n" % e)

Parameters

Responses

Status: default - default response

Schema

setLevel

Set the level for the specified logger

/admin/loggers/{logger}

Usage and SDK Samples

curl -X PUT\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"//admin/loggers/{logger}"

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

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String logger = logger_example; // String | 
        map[String, String] body = ; // map[String, String] | 
        try {
            apiInstance.setLevel(logger, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#setLevel");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String logger = logger_example; // String | 
        map[String, String] body = ; // map[String, String] | 
        try {
            apiInstance.setLevel(logger, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#setLevel");
            e.printStackTrace();
        }
    }
}

String *logger = logger_example; // 
map[String, String] *body = ; //  (optional)

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

// Set the level for the specified logger
[apiInstance setLevelWith:logger
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var KafkaConnectRestApi = require('kafka_connect_rest_api');

var api = new KafkaConnectRestApi.DefaultApi()
var logger = logger_example; // {{String}} 
var opts = { 
  'body':  // {{map[String, String]}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.setLevel(logger, opts, callback);

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

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

            var apiInstance = new DefaultApi();
            var logger = logger_example;  // String | 
            var body = new map[String, String](); // map[String, String] |  (optional) 

            try
            {
                // Set the level for the specified logger
                apiInstance.setLevel(logger, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.setLevel: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiDefaultApi();
$logger = logger_example; // String | 
$body = ; // map[String, String] | 

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

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $logger = logger_example; # String | 
my $body = WWW::SwaggerClient::Object::map[String, String]->new(); # map[String, String] | 

eval { 
    $api_instance->setLevel(logger => $logger, body => $body);
};
if ($@) {
    warn "Exception when calling DefaultApi->setLevel: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
logger = logger_example # String | 
body =  # map[String, String] |  (optional)

try: 
    # Set the level for the specified logger
    api_instance.set_level(logger, body=body)
except ApiException as e:
    print("Exception when calling DefaultApi->setLevel: %s\n" % e)

Parameters

Path parameters

Name	Description
logger*	String Required

Body parameters

Name	Description
body

Responses

Status: default - default response

validateConfigs

Validate the provided configuration against the configuration definition for the specified pluginName

/connector-plugins/{pluginName}/config/validate

Usage and SDK Samples

curl -X PUT\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"//connector-plugins/{pluginName}/config/validate"

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

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String pluginName = pluginName_example; // String | 
        map[String, String] body = ; // map[String, String] | 
        try {
            ConfigInfos result = apiInstance.validateConfigs(pluginName, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#validateConfigs");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String pluginName = pluginName_example; // String | 
        map[String, String] body = ; // map[String, String] | 
        try {
            ConfigInfos result = apiInstance.validateConfigs(pluginName, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#validateConfigs");
            e.printStackTrace();
        }
    }
}

String *pluginName = pluginName_example; // 
map[String, String] *body = ; //  (optional)

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

// Validate the provided configuration against the configuration definition for the specified pluginName
[apiInstance validateConfigsWith:pluginName
    body:body
              completionHandler: ^(ConfigInfos output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var KafkaConnectRestApi = require('kafka_connect_rest_api');

var api = new KafkaConnectRestApi.DefaultApi()
var pluginName = pluginName_example; // {{String}} 
var opts = { 
  'body':  // {{map[String, String]}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.validateConfigs(pluginName, opts, callback);

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

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

            var apiInstance = new DefaultApi();
            var pluginName = pluginName_example;  // String | 
            var body = new map[String, String](); // map[String, String] |  (optional) 

            try
            {
                // Validate the provided configuration against the configuration definition for the specified pluginName
                ConfigInfos result = apiInstance.validateConfigs(pluginName, body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.validateConfigs: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiDefaultApi();
$pluginName = pluginName_example; // String | 
$body = ; // map[String, String] | 

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

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $pluginName = pluginName_example; # String | 
my $body = WWW::SwaggerClient::Object::map[String, String]->new(); # map[String, String] | 

eval { 
    my $result = $api_instance->validateConfigs(pluginName => $pluginName, body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->validateConfigs: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
pluginName = pluginName_example # String | 
body =  # map[String, String] |  (optional)

try: 
    # Validate the provided configuration against the configuration definition for the specified pluginName
    api_response = api_instance.validate_configs(pluginName, body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->validateConfigs: %s\n" % e)

Parameters

Path parameters

Name	Description
pluginName*	String Required

Body parameters

Name	Description
body

Responses

Status: default - default response

Schema

Kafka Connect REST API

API and SDK Documentation

Default

createConnector

Usage and SDK Samples

Parameters

Responses

Status: default - default response

destroyConnector

Usage and SDK Samples

Parameters

Responses

Status: default - default response

getConnector

Usage and SDK Samples

Parameters

Responses

Status: default - default response

getConnectorActiveTopics

Usage and SDK Samples

Parameters

Responses

Status: default - default response

getConnectorConfig

Usage and SDK Samples

Parameters

Responses

Status: default - default response

getConnectorConfigDef

Usage and SDK Samples

Parameters

Responses

Status: default - default response

getConnectorStatus

Usage and SDK Samples

Parameters

Responses

Status: default - default response

getLogger

Usage and SDK Samples

Parameters

Responses

Status: default - default response

getTaskConfigs

Usage and SDK Samples

Parameters

Responses

Status: default - default response

getTaskStatus

Usage and SDK Samples

Parameters

Responses

Status: default - default response

getTasksConfig

Usage and SDK Samples

Parameters

Responses

Status: default - default response

listConnectorPlugins

Usage and SDK Samples

Parameters

Responses

Status: default - default response

listConnectors

Usage and SDK Samples

Parameters

Responses

Status: default - default response

listLoggers

Usage and SDK Samples

Parameters

Responses

Status: default - default response

pauseConnector

Usage and SDK Samples

Parameters

Responses

Status: default - default response

putConnectorConfig

Usage and SDK Samples