Starburst Control Plane Public API

ClusterService

failoverCluster

Trigger cluster failover


/public/api/v1/cluster/{clusterId}:failover

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
"//public/api/v1/cluster/{clusterId}:failover"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ClusterServiceApi;

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

public class ClusterServiceApiExample {

    public static void main(String[] args) {
        
        ClusterServiceApi apiInstance = new ClusterServiceApi();
        String clusterId = clusterId_example; // String | A cluster
        try {
            FailoverResult result = apiInstance.failoverCluster(clusterId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ClusterServiceApi#failoverCluster");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ClusterServiceApi;

public class ClusterServiceApiExample {

    public static void main(String[] args) {
        ClusterServiceApi apiInstance = new ClusterServiceApi();
        String clusterId = clusterId_example; // String | A cluster
        try {
            FailoverResult result = apiInstance.failoverCluster(clusterId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ClusterServiceApi#failoverCluster");
            e.printStackTrace();
        }
    }
}
String *clusterId = clusterId_example; // A cluster

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

[apiInstance failoverClusterWith:clusterId
              completionHandler: ^(FailoverResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var StarburstControlPlanePublicApi = require('starburst_control_plane_public_api');

var api = new StarburstControlPlanePublicApi.ClusterServiceApi()
var clusterId = clusterId_example; // {{String}} A cluster

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

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

            var apiInstance = new ClusterServiceApi();
            var clusterId = clusterId_example;  // String | A cluster

            try
            {
                FailoverResult result = apiInstance.failoverCluster(clusterId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ClusterServiceApi.failoverCluster: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiClusterServiceApi();
$clusterId = clusterId_example; // String | A cluster

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

my $api_instance = WWW::SwaggerClient::ClusterServiceApi->new();
my $clusterId = clusterId_example; # String | A cluster

eval { 
    my $result = $api_instance->failoverCluster(clusterId => $clusterId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ClusterServiceApi->failoverCluster: $@\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.ClusterServiceApi()
clusterId = clusterId_example # String | A cluster

try: 
    api_response = api_instance.failover_cluster(clusterId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ClusterServiceApi->failoverCluster: %s\n" % e)

Parameters

Path parameters
Name Description
clusterId*
String
A cluster
Required

Responses

Status: 200 - Success

{

Cluster failover result

Required: clusterId,decommissioned,promoted
clusterId:
string
decommissioned:
string
promoted:
string
}

Status: 409 - ApiAlreadyExists

{

Already exists

message:
string
}

Status: 400 - ApiBadRequest

{

Invalid request

message:
string

Description of the error

fields:
[

Any fields/values that are invalid or incorrect

string

Any fields/values that are invalid or incorrect

]
}

Status: 401 - ApiUnauthorized

{

Authorization failed

message:
string
}

Status: 403 - ApiForbidden

{

Authorization failed

message:
string
}

getClusterStatus

Get cluster status


/public/api/v1/cluster/{clusterId}/status

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"//public/api/v1/cluster/{clusterId}/status"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ClusterServiceApi;

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

public class ClusterServiceApiExample {

    public static void main(String[] args) {
        
        ClusterServiceApi apiInstance = new ClusterServiceApi();
        String clusterId = clusterId_example; // String | A cluster
        try {
            Status result = apiInstance.getClusterStatus(clusterId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ClusterServiceApi#getClusterStatus");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ClusterServiceApi;

public class ClusterServiceApiExample {

    public static void main(String[] args) {
        ClusterServiceApi apiInstance = new ClusterServiceApi();
        String clusterId = clusterId_example; // String | A cluster
        try {
            Status result = apiInstance.getClusterStatus(clusterId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ClusterServiceApi#getClusterStatus");
            e.printStackTrace();
        }
    }
}
String *clusterId = clusterId_example; // A cluster

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

[apiInstance getClusterStatusWith:clusterId
              completionHandler: ^(Status output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var StarburstControlPlanePublicApi = require('starburst_control_plane_public_api');

var api = new StarburstControlPlanePublicApi.ClusterServiceApi()
var clusterId = clusterId_example; // {{String}} A cluster

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

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

            var apiInstance = new ClusterServiceApi();
            var clusterId = clusterId_example;  // String | A cluster

            try
            {
                Status result = apiInstance.getClusterStatus(clusterId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ClusterServiceApi.getClusterStatus: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiClusterServiceApi();
$clusterId = clusterId_example; // String | A cluster

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

my $api_instance = WWW::SwaggerClient::ClusterServiceApi->new();
my $clusterId = clusterId_example; # String | A cluster

eval { 
    my $result = $api_instance->getClusterStatus(clusterId => $clusterId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ClusterServiceApi->getClusterStatus: $@\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.ClusterServiceApi()
clusterId = clusterId_example # String | A cluster

try: 
    api_response = api_instance.get_cluster_status(clusterId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ClusterServiceApi->getClusterStatus: %s\n" % e)

Parameters

Path parameters
Name Description
clusterId*
String
A cluster
Required

Responses

Status: 200 - Success

{

Cluster status

Required: activeCoordinator,activeQueries,clusterId,failoverReadiness,standbyCoordinators
clusterId:
string
activeCoordinator:
{
Required: healthStatus,instanceId,uri
instanceId:
string
uri:
string
healthStatus:
string
}
standbyCoordinators:
[
{
Required: healthStatus,instanceId,uri
instanceId:
string
uri:
string
healthStatus:
string
}
]
activeQueries:
{
Required: queuedQueryCount,runningQueryCount
runningQueryCount:
integer (int32)
queuedQueryCount:
integer (int32)
}
failoverReadiness:
{
Required: code,reason
code:
string
reason:
string
}
}

Status: 400 - ApiBadRequest

{

Invalid request

message:
string

Description of the error

fields:
[

Any fields/values that are invalid or incorrect

string

Any fields/values that are invalid or incorrect

]
}

Status: 401 - ApiUnauthorized

{

Authorization failed

message:
string
}

Status: 403 - ApiForbidden

{

Authorization failed

message:
string
}

Status: 404 - ApiNotFound

{

A resource or required component was not found

Required: message
message:
string

Name of the resource

description:
string

Violation description

fields:
[

Any fields/values that weren't found

string

Any fields/values that weren't found

]
}

DataSourceService

createDataSource

Create a data source


/public/api/v1/dataSource

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"//public/api/v1/dataSource"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DataSourceServiceApi;

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

public class DataSourceServiceApiExample {

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

public class DataSourceServiceApiExample {

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

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

[apiInstance createDataSourceWith:body
              completionHandler: ^(DataSource output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var StarburstControlPlanePublicApi = require('starburst_control_plane_public_api');

var api = new StarburstControlPlanePublicApi.DataSourceServiceApi()
var body = ; // {{DataSourceRequest}} 

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

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

            var apiInstance = new DataSourceServiceApi();
            var body = new DataSourceRequest(); // DataSourceRequest | 

            try
            {
                DataSource result = apiInstance.createDataSource(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DataSourceServiceApi.createDataSource: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiDataSourceServiceApi();
$body = ; // DataSourceRequest | 

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

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

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

try: 
    api_response = api_instance.create_data_source(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DataSourceServiceApi->createDataSource: %s\n" % e)

Parameters

Body parameters
Name Description
body *
{

Create a new data source

Required: type
type:
string
}

Responses

Status: 200 - Success

{

A data source

Required: type
type:
string
}

Status: 400 - ApiBadRequest

{

Invalid request

message:
string

Description of the error

fields:
[

Any fields/values that are invalid or incorrect

string

Any fields/values that are invalid or incorrect

]
}

Status: 401 - ApiUnauthorized

{

Authorization failed

message:
string
}

Status: 403 - ApiForbidden

{

Authorization failed

message:
string
}

Status: 409 - ApiAlreadyExists

{

Already exists

message:
string
}

deleteDataSource

Delete a data source


/public/api/v1/dataSource/{dataSourceId}

Usage and SDK Samples

curl -X DELETE\
-H "Accept: application/json"\
"//public/api/v1/dataSource/{dataSourceId}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DataSourceServiceApi;

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

public class DataSourceServiceApiExample {

    public static void main(String[] args) {
        
        DataSourceServiceApi apiInstance = new DataSourceServiceApi();
        String dataSourceId = dataSourceId_example; // String | A data source
        try {
            apiInstance.deleteDataSource(dataSourceId);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataSourceServiceApi#deleteDataSource");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DataSourceServiceApi;

public class DataSourceServiceApiExample {

    public static void main(String[] args) {
        DataSourceServiceApi apiInstance = new DataSourceServiceApi();
        String dataSourceId = dataSourceId_example; // String | A data source
        try {
            apiInstance.deleteDataSource(dataSourceId);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataSourceServiceApi#deleteDataSource");
            e.printStackTrace();
        }
    }
}
String *dataSourceId = dataSourceId_example; // A data source

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

[apiInstance deleteDataSourceWith:dataSourceId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var StarburstControlPlanePublicApi = require('starburst_control_plane_public_api');

var api = new StarburstControlPlanePublicApi.DataSourceServiceApi()
var dataSourceId = dataSourceId_example; // {{String}} A data source

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

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

            var apiInstance = new DataSourceServiceApi();
            var dataSourceId = dataSourceId_example;  // String | A data source

            try
            {
                apiInstance.deleteDataSource(dataSourceId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DataSourceServiceApi.deleteDataSource: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiDataSourceServiceApi();
$dataSourceId = dataSourceId_example; // String | A data source

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

my $api_instance = WWW::SwaggerClient::DataSourceServiceApi->new();
my $dataSourceId = dataSourceId_example; # String | A data source

eval { 
    $api_instance->deleteDataSource(dataSourceId => $dataSourceId);
};
if ($@) {
    warn "Exception when calling DataSourceServiceApi->deleteDataSource: $@\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.DataSourceServiceApi()
dataSourceId = dataSourceId_example # String | A data source

try: 
    api_instance.delete_data_source(dataSourceId)
except ApiException as e:
    print("Exception when calling DataSourceServiceApi->deleteDataSource: %s\n" % e)

Parameters

Path parameters
Name Description
dataSourceId*
String
A data source
Required

Responses

Status: 204 - Success

Status: 400 - ApiBadRequest

{

Invalid request

message:
string

Description of the error

fields:
[

Any fields/values that are invalid or incorrect

string

Any fields/values that are invalid or incorrect

]
}

Status: 401 - ApiUnauthorized

{

Authorization failed

message:
string
}

Status: 403 - ApiForbidden

{

Authorization failed

message:
string
}

Status: 404 - ApiNotFound

{

A resource or required component was not found

Required: message
message:
string

Name of the resource

description:
string

Violation description

fields:
[

Any fields/values that weren't found

string

Any fields/values that weren't found

]
}

getDataSource

Get a data source by ID


/public/api/v1/dataSource/{dataSourceId}

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"//public/api/v1/dataSource/{dataSourceId}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DataSourceServiceApi;

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

public class DataSourceServiceApiExample {

    public static void main(String[] args) {
        
        DataSourceServiceApi apiInstance = new DataSourceServiceApi();
        String dataSourceId = dataSourceId_example; // String | A data source
        try {
            DataSource result = apiInstance.getDataSource(dataSourceId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataSourceServiceApi#getDataSource");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DataSourceServiceApi;

public class DataSourceServiceApiExample {

    public static void main(String[] args) {
        DataSourceServiceApi apiInstance = new DataSourceServiceApi();
        String dataSourceId = dataSourceId_example; // String | A data source
        try {
            DataSource result = apiInstance.getDataSource(dataSourceId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataSourceServiceApi#getDataSource");
            e.printStackTrace();
        }
    }
}
String *dataSourceId = dataSourceId_example; // A data source

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

[apiInstance getDataSourceWith:dataSourceId
              completionHandler: ^(DataSource output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var StarburstControlPlanePublicApi = require('starburst_control_plane_public_api');

var api = new StarburstControlPlanePublicApi.DataSourceServiceApi()
var dataSourceId = dataSourceId_example; // {{String}} A data source

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

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

            var apiInstance = new DataSourceServiceApi();
            var dataSourceId = dataSourceId_example;  // String | A data source

            try
            {
                DataSource result = apiInstance.getDataSource(dataSourceId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DataSourceServiceApi.getDataSource: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiDataSourceServiceApi();
$dataSourceId = dataSourceId_example; // String | A data source

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

my $api_instance = WWW::SwaggerClient::DataSourceServiceApi->new();
my $dataSourceId = dataSourceId_example; # String | A data source

eval { 
    my $result = $api_instance->getDataSource(dataSourceId => $dataSourceId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DataSourceServiceApi->getDataSource: $@\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.DataSourceServiceApi()
dataSourceId = dataSourceId_example # String | A data source

try: 
    api_response = api_instance.get_data_source(dataSourceId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DataSourceServiceApi->getDataSource: %s\n" % e)

Parameters

Path parameters
Name Description
dataSourceId*
String
A data source
Required

Responses

Status: 200 - Success

{

A data source

Required: type
type:
string
}

Status: 400 - ApiBadRequest

{

Invalid request

message:
string

Description of the error

fields:
[

Any fields/values that are invalid or incorrect

string

Any fields/values that are invalid or incorrect

]
}

Status: 401 - ApiUnauthorized

{

Authorization failed

message:
string
}

Status: 403 - ApiForbidden

{

Authorization failed

message:
string
}

Status: 404 - ApiNotFound

{

A resource or required component was not found

Required: message
message:
string

Name of the resource

description:
string

Violation description

fields:
[

Any fields/values that weren't found

string

Any fields/values that weren't found

]
}

listDataSource

List all data sources


/public/api/v1/dataSource

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"//public/api/v1/dataSource"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DataSourceServiceApi;

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

public class DataSourceServiceApiExample {

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

public class DataSourceServiceApiExample {

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

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

[apiInstance listDataSourceWithCompletionHandler: 
              ^(PaginatedDataSource output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var StarburstControlPlanePublicApi = require('starburst_control_plane_public_api');

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

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

            var apiInstance = new DataSourceServiceApi();

            try
            {
                PaginatedDataSource result = apiInstance.listDataSource();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DataSourceServiceApi.listDataSource: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

try: 
    api_response = api_instance.list_data_source()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DataSourceServiceApi->listDataSource: %s\n" % e)

Parameters

Responses

Status: 200 - Success

{
nextPageToken:
string

The next page token to use or "" if there are no more pages.

result:
[

A page of results.

{

A data source

Required: type
type:
string
}
]
}

Status: 400 - ApiBadRequest

{

Invalid request

message:
string

Description of the error

fields:
[

Any fields/values that are invalid or incorrect

string

Any fields/values that are invalid or incorrect

]
}

Status: 401 - ApiUnauthorized

{

Authorization failed

message:
string
}

Status: 403 - ApiForbidden

{

Authorization failed

message:
string
}

Status: 404 - ApiNotFound

{

A resource or required component was not found

Required: message
message:
string

Name of the resource

description:
string

Violation description

fields:
[

Any fields/values that weren't found

string

Any fields/values that weren't found

]
}

updateDataSource

Update a data source


/public/api/v1/dataSource/{dataSourceId}

Usage and SDK Samples

curl -X PUT\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"//public/api/v1/dataSource/{dataSourceId}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DataSourceServiceApi;

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

public class DataSourceServiceApiExample {

    public static void main(String[] args) {
        
        DataSourceServiceApi apiInstance = new DataSourceServiceApi();
        DataSourceRequest body = ; // DataSourceRequest | 
        String dataSourceId = dataSourceId_example; // String | A data source
        try {
            DataSource result = apiInstance.updateDataSource(body, dataSourceId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataSourceServiceApi#updateDataSource");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DataSourceServiceApi;

public class DataSourceServiceApiExample {

    public static void main(String[] args) {
        DataSourceServiceApi apiInstance = new DataSourceServiceApi();
        DataSourceRequest body = ; // DataSourceRequest | 
        String dataSourceId = dataSourceId_example; // String | A data source
        try {
            DataSource result = apiInstance.updateDataSource(body, dataSourceId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataSourceServiceApi#updateDataSource");
            e.printStackTrace();
        }
    }
}
DataSourceRequest *body = ; // 
String *dataSourceId = dataSourceId_example; // A data source

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

[apiInstance updateDataSourceWith:body
    dataSourceId:dataSourceId
              completionHandler: ^(DataSource output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var StarburstControlPlanePublicApi = require('starburst_control_plane_public_api');

var api = new StarburstControlPlanePublicApi.DataSourceServiceApi()
var body = ; // {{DataSourceRequest}} 
var dataSourceId = dataSourceId_example; // {{String}} A data source

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

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

            var apiInstance = new DataSourceServiceApi();
            var body = new DataSourceRequest(); // DataSourceRequest | 
            var dataSourceId = dataSourceId_example;  // String | A data source

            try
            {
                DataSource result = apiInstance.updateDataSource(body, dataSourceId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DataSourceServiceApi.updateDataSource: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiDataSourceServiceApi();
$body = ; // DataSourceRequest | 
$dataSourceId = dataSourceId_example; // String | A data source

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

my $api_instance = WWW::SwaggerClient::DataSourceServiceApi->new();
my $body = WWW::SwaggerClient::Object::DataSourceRequest->new(); # DataSourceRequest | 
my $dataSourceId = dataSourceId_example; # String | A data source

eval { 
    my $result = $api_instance->updateDataSource(body => $body, dataSourceId => $dataSourceId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DataSourceServiceApi->updateDataSource: $@\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.DataSourceServiceApi()
body =  # DataSourceRequest | 
dataSourceId = dataSourceId_example # String | A data source

try: 
    api_response = api_instance.update_data_source(body, dataSourceId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DataSourceServiceApi->updateDataSource: %s\n" % e)

Parameters

Path parameters
Name Description
dataSourceId*
String
A data source
Required
Body parameters
Name Description
body *
{

Create a new data source

Required: type
type:
string
}

Responses

Status: 200 - Success

{

A data source

Required: type
type:
string
}

Status: 400 - ApiBadRequest

{

Invalid request

message:
string

Description of the error

fields:
[

Any fields/values that are invalid or incorrect

string

Any fields/values that are invalid or incorrect

]
}

Status: 401 - ApiUnauthorized

{

Authorization failed

message:
string
}

Status: 403 - ApiForbidden

{

Authorization failed

message:
string
}

Status: 409 - ApiAlreadyExists

{

Already exists

message:
string
}

Status: 404 - ApiNotFound

{

A resource or required component was not found

Required: message
message:
string

Name of the resource

description:
string

Violation description

fields:
[

Any fields/values that weren't found

string

Any fields/values that weren't found

]
}

RoutingRuleService

createRoutingRule

Create a routing rule


/public/api/v1/routingRule

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"//public/api/v1/routingRule"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.RoutingRuleServiceApi;

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

public class RoutingRuleServiceApiExample {

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

public class RoutingRuleServiceApiExample {

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

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

[apiInstance createRoutingRuleWith:body
              completionHandler: ^(RoutingRule output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var StarburstControlPlanePublicApi = require('starburst_control_plane_public_api');

var api = new StarburstControlPlanePublicApi.RoutingRuleServiceApi()
var body = ; // {{RoutingRuleAttributes}} 

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

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

            var apiInstance = new RoutingRuleServiceApi();
            var body = new RoutingRuleAttributes(); // RoutingRuleAttributes | 

            try
            {
                RoutingRule result = apiInstance.createRoutingRule(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling RoutingRuleServiceApi.createRoutingRule: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiRoutingRuleServiceApi();
$body = ; // RoutingRuleAttributes | 

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

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

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

try: 
    api_response = api_instance.create_routing_rule(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RoutingRuleServiceApi->createRoutingRule: %s\n" % e)

Parameters

Body parameters
Name Description
body *
{

Attributes for creating or updating a routing rule

Required: action,condition,name,priority
name:
string
description:
string
priority:
integer (int32)
condition:
{
Required: orClauses
orClauses:
}
action:
{
Required: type
type:
}
}

Responses

Status: 200 - Success

{

A tag-based routing rule

Required: action,condition,name,priority,routingRuleId
routingRuleId:
string
name:
string
description:
string
priority:
integer (int32)
condition:
{
Required: orClauses
orClauses:
[
{
Required: expressions
expressions:
[
{
Required: operator,tagKey,value
tagKey:
string
operator:
string
Enum: EQUALS, MATCHESPATTERN
value:
string
}
]
}
]
}
action:
{
Required: type
type:
string
}
}

Status: 400 - ApiBadRequest

{

Invalid request

message:
string

Description of the error

fields:
[

Any fields/values that are invalid or incorrect

string

Any fields/values that are invalid or incorrect

]
}

Status: 401 - ApiUnauthorized

{

Authorization failed

message:
string
}

Status: 403 - ApiForbidden

{

Authorization failed

message:
string
}

Status: 409 - ApiAlreadyExists

{

Already exists

message:
string
}

deleteRoutingRule

Delete a routing rule


/public/api/v1/routingRule/{routingRuleId}

Usage and SDK Samples

curl -X DELETE\
-H "Accept: application/json"\
"//public/api/v1/routingRule/{routingRuleId}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.RoutingRuleServiceApi;

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

public class RoutingRuleServiceApiExample {

    public static void main(String[] args) {
        
        RoutingRuleServiceApi apiInstance = new RoutingRuleServiceApi();
        String routingRuleId = routingRuleId_example; // String | A tag-based routing rule
        try {
            apiInstance.deleteRoutingRule(routingRuleId);
        } catch (ApiException e) {
            System.err.println("Exception when calling RoutingRuleServiceApi#deleteRoutingRule");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.RoutingRuleServiceApi;

public class RoutingRuleServiceApiExample {

    public static void main(String[] args) {
        RoutingRuleServiceApi apiInstance = new RoutingRuleServiceApi();
        String routingRuleId = routingRuleId_example; // String | A tag-based routing rule
        try {
            apiInstance.deleteRoutingRule(routingRuleId);
        } catch (ApiException e) {
            System.err.println("Exception when calling RoutingRuleServiceApi#deleteRoutingRule");
            e.printStackTrace();
        }
    }
}
String *routingRuleId = routingRuleId_example; // A tag-based routing rule

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

[apiInstance deleteRoutingRuleWith:routingRuleId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var StarburstControlPlanePublicApi = require('starburst_control_plane_public_api');

var api = new StarburstControlPlanePublicApi.RoutingRuleServiceApi()
var routingRuleId = routingRuleId_example; // {{String}} A tag-based routing rule

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

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

            var apiInstance = new RoutingRuleServiceApi();
            var routingRuleId = routingRuleId_example;  // String | A tag-based routing rule

            try
            {
                apiInstance.deleteRoutingRule(routingRuleId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling RoutingRuleServiceApi.deleteRoutingRule: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiRoutingRuleServiceApi();
$routingRuleId = routingRuleId_example; // String | A tag-based routing rule

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

my $api_instance = WWW::SwaggerClient::RoutingRuleServiceApi->new();
my $routingRuleId = routingRuleId_example; # String | A tag-based routing rule

eval { 
    $api_instance->deleteRoutingRule(routingRuleId => $routingRuleId);
};
if ($@) {
    warn "Exception when calling RoutingRuleServiceApi->deleteRoutingRule: $@\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.RoutingRuleServiceApi()
routingRuleId = routingRuleId_example # String | A tag-based routing rule

try: 
    api_instance.delete_routing_rule(routingRuleId)
except ApiException as e:
    print("Exception when calling RoutingRuleServiceApi->deleteRoutingRule: %s\n" % e)

Parameters

Path parameters
Name Description
routingRuleId*
String
A tag-based routing rule
Required

Responses

Status: 204 - Success

Status: 400 - ApiBadRequest

{

Invalid request

message:
string

Description of the error

fields:
[

Any fields/values that are invalid or incorrect

string

Any fields/values that are invalid or incorrect

]
}

Status: 401 - ApiUnauthorized

{

Authorization failed

message:
string
}

Status: 403 - ApiForbidden

{

Authorization failed

message:
string
}

Status: 404 - ApiNotFound

{

A resource or required component was not found

Required: message
message:
string

Name of the resource

description:
string

Violation description

fields:
[

Any fields/values that weren't found

string

Any fields/values that weren't found

]
}

getRoutingRule

Get a routing rule by ID


/public/api/v1/routingRule/{routingRuleId}

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"//public/api/v1/routingRule/{routingRuleId}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.RoutingRuleServiceApi;

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

public class RoutingRuleServiceApiExample {

    public static void main(String[] args) {
        
        RoutingRuleServiceApi apiInstance = new RoutingRuleServiceApi();
        String routingRuleId = routingRuleId_example; // String | A tag-based routing rule
        try {
            RoutingRule result = apiInstance.getRoutingRule(routingRuleId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RoutingRuleServiceApi#getRoutingRule");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.RoutingRuleServiceApi;

public class RoutingRuleServiceApiExample {

    public static void main(String[] args) {
        RoutingRuleServiceApi apiInstance = new RoutingRuleServiceApi();
        String routingRuleId = routingRuleId_example; // String | A tag-based routing rule
        try {
            RoutingRule result = apiInstance.getRoutingRule(routingRuleId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RoutingRuleServiceApi#getRoutingRule");
            e.printStackTrace();
        }
    }
}
String *routingRuleId = routingRuleId_example; // A tag-based routing rule

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

[apiInstance getRoutingRuleWith:routingRuleId
              completionHandler: ^(RoutingRule output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var StarburstControlPlanePublicApi = require('starburst_control_plane_public_api');

var api = new StarburstControlPlanePublicApi.RoutingRuleServiceApi()
var routingRuleId = routingRuleId_example; // {{String}} A tag-based routing rule

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

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

            var apiInstance = new RoutingRuleServiceApi();
            var routingRuleId = routingRuleId_example;  // String | A tag-based routing rule

            try
            {
                RoutingRule result = apiInstance.getRoutingRule(routingRuleId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling RoutingRuleServiceApi.getRoutingRule: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiRoutingRuleServiceApi();
$routingRuleId = routingRuleId_example; // String | A tag-based routing rule

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

my $api_instance = WWW::SwaggerClient::RoutingRuleServiceApi->new();
my $routingRuleId = routingRuleId_example; # String | A tag-based routing rule

eval { 
    my $result = $api_instance->getRoutingRule(routingRuleId => $routingRuleId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling RoutingRuleServiceApi->getRoutingRule: $@\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.RoutingRuleServiceApi()
routingRuleId = routingRuleId_example # String | A tag-based routing rule

try: 
    api_response = api_instance.get_routing_rule(routingRuleId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RoutingRuleServiceApi->getRoutingRule: %s\n" % e)

Parameters

Path parameters
Name Description
routingRuleId*
String
A tag-based routing rule
Required

Responses

Status: 200 - Success

{

A tag-based routing rule

Required: action,condition,name,priority,routingRuleId
routingRuleId:
string
name:
string
description:
string
priority:
integer (int32)
condition:
{
Required: orClauses
orClauses:
[
{
Required: expressions
expressions:
[
{
Required: operator,tagKey,value
tagKey:
string
operator:
string
Enum: EQUALS, MATCHESPATTERN
value:
string
}
]
}
]
}
action:
{
Required: type
type:
string
}
}

Status: 400 - ApiBadRequest

{

Invalid request

message:
string

Description of the error

fields:
[

Any fields/values that are invalid or incorrect

string

Any fields/values that are invalid or incorrect

]
}

Status: 401 - ApiUnauthorized

{

Authorization failed

message:
string
}

Status: 403 - ApiForbidden

{

Authorization failed

message:
string
}

Status: 404 - ApiNotFound

{

A resource or required component was not found

Required: message
message:
string

Name of the resource

description:
string

Violation description

fields:
[

Any fields/values that weren't found

string

Any fields/values that weren't found

]
}

listRoutingRule

List all routing rules


/public/api/v1/routingRule

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"//public/api/v1/routingRule"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.RoutingRuleServiceApi;

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

public class RoutingRuleServiceApiExample {

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

public class RoutingRuleServiceApiExample {

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

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

[apiInstance listRoutingRuleWithCompletionHandler: 
              ^(PaginatedRoutingRule output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var StarburstControlPlanePublicApi = require('starburst_control_plane_public_api');

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

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

            var apiInstance = new RoutingRuleServiceApi();

            try
            {
                PaginatedRoutingRule result = apiInstance.listRoutingRule();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling RoutingRuleServiceApi.listRoutingRule: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

try: 
    api_response = api_instance.list_routing_rule()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RoutingRuleServiceApi->listRoutingRule: %s\n" % e)

Parameters

Responses

Status: 200 - Success

{
nextPageToken:
string

The next page token to use or "" if there are no more pages.

result:
[

A page of results.

{

A tag-based routing rule

Required: action,condition,name,priority,routingRuleId
routingRuleId:
string
name:
string
description:
string
priority:
integer (int32)
condition:
{
Required: orClauses
orClauses:
[
{
Required: expressions
expressions:
[
{
Required: operator,tagKey,value
tagKey:
string
operator:
string
Enum: EQUALS, MATCHESPATTERN
value:
string
}
]
}
]
}
action:
{
Required: type
type:
string
}
}
]
}

Status: 400 - ApiBadRequest

{

Invalid request

message:
string

Description of the error

fields:
[

Any fields/values that are invalid or incorrect

string

Any fields/values that are invalid or incorrect

]
}

Status: 401 - ApiUnauthorized

{

Authorization failed

message:
string
}

Status: 403 - ApiForbidden

{

Authorization failed

message:
string
}

Status: 404 - ApiNotFound

{

A resource or required component was not found

Required: message
message:
string

Name of the resource

description:
string

Violation description

fields:
[

Any fields/values that weren't found

string

Any fields/values that weren't found

]
}

updateRoutingRule

Update a routing rule


/public/api/v1/routingRule/{routingRuleId}

Usage and SDK Samples

curl -X PUT\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"//public/api/v1/routingRule/{routingRuleId}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.RoutingRuleServiceApi;

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

public class RoutingRuleServiceApiExample {

    public static void main(String[] args) {
        
        RoutingRuleServiceApi apiInstance = new RoutingRuleServiceApi();
        RoutingRuleAttributes body = ; // RoutingRuleAttributes | 
        String routingRuleId = routingRuleId_example; // String | A tag-based routing rule
        try {
            RoutingRule result = apiInstance.updateRoutingRule(body, routingRuleId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RoutingRuleServiceApi#updateRoutingRule");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.RoutingRuleServiceApi;

public class RoutingRuleServiceApiExample {

    public static void main(String[] args) {
        RoutingRuleServiceApi apiInstance = new RoutingRuleServiceApi();
        RoutingRuleAttributes body = ; // RoutingRuleAttributes | 
        String routingRuleId = routingRuleId_example; // String | A tag-based routing rule
        try {
            RoutingRule result = apiInstance.updateRoutingRule(body, routingRuleId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RoutingRuleServiceApi#updateRoutingRule");
            e.printStackTrace();
        }
    }
}
RoutingRuleAttributes *body = ; // 
String *routingRuleId = routingRuleId_example; // A tag-based routing rule

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

[apiInstance updateRoutingRuleWith:body
    routingRuleId:routingRuleId
              completionHandler: ^(RoutingRule output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var StarburstControlPlanePublicApi = require('starburst_control_plane_public_api');

var api = new StarburstControlPlanePublicApi.RoutingRuleServiceApi()
var body = ; // {{RoutingRuleAttributes}} 
var routingRuleId = routingRuleId_example; // {{String}} A tag-based routing rule

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

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

            var apiInstance = new RoutingRuleServiceApi();
            var body = new RoutingRuleAttributes(); // RoutingRuleAttributes | 
            var routingRuleId = routingRuleId_example;  // String | A tag-based routing rule

            try
            {
                RoutingRule result = apiInstance.updateRoutingRule(body, routingRuleId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling RoutingRuleServiceApi.updateRoutingRule: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiRoutingRuleServiceApi();
$body = ; // RoutingRuleAttributes | 
$routingRuleId = routingRuleId_example; // String | A tag-based routing rule

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

my $api_instance = WWW::SwaggerClient::RoutingRuleServiceApi->new();
my $body = WWW::SwaggerClient::Object::RoutingRuleAttributes->new(); # RoutingRuleAttributes | 
my $routingRuleId = routingRuleId_example; # String | A tag-based routing rule

eval { 
    my $result = $api_instance->updateRoutingRule(body => $body, routingRuleId => $routingRuleId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling RoutingRuleServiceApi->updateRoutingRule: $@\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.RoutingRuleServiceApi()
body =  # RoutingRuleAttributes | 
routingRuleId = routingRuleId_example # String | A tag-based routing rule

try: 
    api_response = api_instance.update_routing_rule(body, routingRuleId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RoutingRuleServiceApi->updateRoutingRule: %s\n" % e)

Parameters

Path parameters
Name Description
routingRuleId*
String
A tag-based routing rule
Required
Body parameters
Name Description
body *
{

Attributes for creating or updating a routing rule

Required: action,condition,name,priority
name:
string
description:
string
priority:
integer (int32)
condition:
{
Required: orClauses
orClauses:
}
action:
{
Required: type
type:
}
}

Responses

Status: 200 - Success

{

A tag-based routing rule

Required: action,condition,name,priority,routingRuleId
routingRuleId:
string
name:
string
description:
string
priority:
integer (int32)
condition:
{
Required: orClauses
orClauses:
[
{
Required: expressions
expressions:
[
{
Required: operator,tagKey,value
tagKey:
string
operator:
string
Enum: EQUALS, MATCHESPATTERN
value:
string
}
]
}
]
}
action:
{
Required: type
type:
string
}
}

Status: 400 - ApiBadRequest

{

Invalid request

message:
string

Description of the error

fields:
[

Any fields/values that are invalid or incorrect

string

Any fields/values that are invalid or incorrect

]
}

Status: 401 - ApiUnauthorized

{

Authorization failed

message:
string
}

Status: 403 - ApiForbidden

{

Authorization failed

message:
string
}

Status: 409 - ApiAlreadyExists

{

Already exists

message:
string
}

Status: 404 - ApiNotFound

{

A resource or required component was not found

Required: message
message:
string

Name of the resource

description:
string

Violation description

fields:
[

Any fields/values that weren't found

string

Any fields/values that weren't found

]
}

TaggingRuleService

createTaggingRule

Create a tagging rule


/public/api/v1/taggingRule

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"//public/api/v1/taggingRule"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TaggingRuleServiceApi;

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

public class TaggingRuleServiceApiExample {

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

public class TaggingRuleServiceApiExample {

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

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

[apiInstance createTaggingRuleWith:body
              completionHandler: ^(TaggingRule output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var StarburstControlPlanePublicApi = require('starburst_control_plane_public_api');

var api = new StarburstControlPlanePublicApi.TaggingRuleServiceApi()
var body = ; // {{TaggingRuleAttributes}} 

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

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

            var apiInstance = new TaggingRuleServiceApi();
            var body = new TaggingRuleAttributes(); // TaggingRuleAttributes | 

            try
            {
                TaggingRule result = apiInstance.createTaggingRule(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TaggingRuleServiceApi.createTaggingRule: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiTaggingRuleServiceApi();
$body = ; // TaggingRuleAttributes | 

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

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

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

try: 
    api_response = api_instance.create_tagging_rule(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TaggingRuleServiceApi->createTaggingRule: %s\n" % e)

Parameters

Body parameters
Name Description
body *
{

Attributes for creating or updating a tagging rule

Required: action,condition,name,priority,tagKey
name:
string
tagKey:
string
description:
string
priority:
integer (int32)
condition:
{
Required: orClauses
orClauses:
}
action:
{
Required: type
type:
}
}

Responses

Status: 200 - Success

{

A tagging rule

Required: action,condition,name,priority,tagKey,taggingRuleId
taggingRuleId:
string
name:
string
tagKey:
string
description:
string
priority:
integer (int32)
condition:
{
Required: orClauses
orClauses:
[
{
Required: expressions
expressions:
[
{
Required: operator,tagKey,value
tagKey:
string
operator:
string
Enum: EQUALS, MATCHESPATTERN
value:
string
}
]
}
]
}
action:
{
Required: type
type:
string
}
}

Status: 400 - ApiBadRequest

{

Invalid request

message:
string

Description of the error

fields:
[

Any fields/values that are invalid or incorrect

string

Any fields/values that are invalid or incorrect

]
}

Status: 401 - ApiUnauthorized

{

Authorization failed

message:
string
}

Status: 403 - ApiForbidden

{

Authorization failed

message:
string
}

Status: 409 - ApiAlreadyExists

{

Already exists

message:
string
}

deleteTaggingRule

Delete a tagging rule


/public/api/v1/taggingRule/{taggingRuleId}

Usage and SDK Samples

curl -X DELETE\
-H "Accept: application/json"\
"//public/api/v1/taggingRule/{taggingRuleId}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TaggingRuleServiceApi;

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

public class TaggingRuleServiceApiExample {

    public static void main(String[] args) {
        
        TaggingRuleServiceApi apiInstance = new TaggingRuleServiceApi();
        String taggingRuleId = taggingRuleId_example; // String | A tagging rule
        try {
            apiInstance.deleteTaggingRule(taggingRuleId);
        } catch (ApiException e) {
            System.err.println("Exception when calling TaggingRuleServiceApi#deleteTaggingRule");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.TaggingRuleServiceApi;

public class TaggingRuleServiceApiExample {

    public static void main(String[] args) {
        TaggingRuleServiceApi apiInstance = new TaggingRuleServiceApi();
        String taggingRuleId = taggingRuleId_example; // String | A tagging rule
        try {
            apiInstance.deleteTaggingRule(taggingRuleId);
        } catch (ApiException e) {
            System.err.println("Exception when calling TaggingRuleServiceApi#deleteTaggingRule");
            e.printStackTrace();
        }
    }
}
String *taggingRuleId = taggingRuleId_example; // A tagging rule

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

[apiInstance deleteTaggingRuleWith:taggingRuleId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var StarburstControlPlanePublicApi = require('starburst_control_plane_public_api');

var api = new StarburstControlPlanePublicApi.TaggingRuleServiceApi()
var taggingRuleId = taggingRuleId_example; // {{String}} A tagging rule

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

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

            var apiInstance = new TaggingRuleServiceApi();
            var taggingRuleId = taggingRuleId_example;  // String | A tagging rule

            try
            {
                apiInstance.deleteTaggingRule(taggingRuleId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TaggingRuleServiceApi.deleteTaggingRule: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiTaggingRuleServiceApi();
$taggingRuleId = taggingRuleId_example; // String | A tagging rule

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

my $api_instance = WWW::SwaggerClient::TaggingRuleServiceApi->new();
my $taggingRuleId = taggingRuleId_example; # String | A tagging rule

eval { 
    $api_instance->deleteTaggingRule(taggingRuleId => $taggingRuleId);
};
if ($@) {
    warn "Exception when calling TaggingRuleServiceApi->deleteTaggingRule: $@\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.TaggingRuleServiceApi()
taggingRuleId = taggingRuleId_example # String | A tagging rule

try: 
    api_instance.delete_tagging_rule(taggingRuleId)
except ApiException as e:
    print("Exception when calling TaggingRuleServiceApi->deleteTaggingRule: %s\n" % e)

Parameters

Path parameters
Name Description
taggingRuleId*
String
A tagging rule
Required

Responses

Status: 204 - Success

Status: 400 - ApiBadRequest

{

Invalid request

message:
string

Description of the error

fields:
[

Any fields/values that are invalid or incorrect

string

Any fields/values that are invalid or incorrect

]
}

Status: 401 - ApiUnauthorized

{

Authorization failed

message:
string
}

Status: 403 - ApiForbidden

{

Authorization failed

message:
string
}

Status: 404 - ApiNotFound

{

A resource or required component was not found

Required: message
message:
string

Name of the resource

description:
string

Violation description

fields:
[

Any fields/values that weren't found

string

Any fields/values that weren't found

]
}

getTaggingRule

Get a tagging rule by ID


/public/api/v1/taggingRule/{taggingRuleId}

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"//public/api/v1/taggingRule/{taggingRuleId}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TaggingRuleServiceApi;

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

public class TaggingRuleServiceApiExample {

    public static void main(String[] args) {
        
        TaggingRuleServiceApi apiInstance = new TaggingRuleServiceApi();
        String taggingRuleId = taggingRuleId_example; // String | A tagging rule
        try {
            TaggingRule result = apiInstance.getTaggingRule(taggingRuleId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TaggingRuleServiceApi#getTaggingRule");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.TaggingRuleServiceApi;

public class TaggingRuleServiceApiExample {

    public static void main(String[] args) {
        TaggingRuleServiceApi apiInstance = new TaggingRuleServiceApi();
        String taggingRuleId = taggingRuleId_example; // String | A tagging rule
        try {
            TaggingRule result = apiInstance.getTaggingRule(taggingRuleId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TaggingRuleServiceApi#getTaggingRule");
            e.printStackTrace();
        }
    }
}
String *taggingRuleId = taggingRuleId_example; // A tagging rule

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

[apiInstance getTaggingRuleWith:taggingRuleId
              completionHandler: ^(TaggingRule output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var StarburstControlPlanePublicApi = require('starburst_control_plane_public_api');

var api = new StarburstControlPlanePublicApi.TaggingRuleServiceApi()
var taggingRuleId = taggingRuleId_example; // {{String}} A tagging rule

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

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

            var apiInstance = new TaggingRuleServiceApi();
            var taggingRuleId = taggingRuleId_example;  // String | A tagging rule

            try
            {
                TaggingRule result = apiInstance.getTaggingRule(taggingRuleId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TaggingRuleServiceApi.getTaggingRule: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiTaggingRuleServiceApi();
$taggingRuleId = taggingRuleId_example; // String | A tagging rule

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

my $api_instance = WWW::SwaggerClient::TaggingRuleServiceApi->new();
my $taggingRuleId = taggingRuleId_example; # String | A tagging rule

eval { 
    my $result = $api_instance->getTaggingRule(taggingRuleId => $taggingRuleId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TaggingRuleServiceApi->getTaggingRule: $@\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.TaggingRuleServiceApi()
taggingRuleId = taggingRuleId_example # String | A tagging rule

try: 
    api_response = api_instance.get_tagging_rule(taggingRuleId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TaggingRuleServiceApi->getTaggingRule: %s\n" % e)

Parameters

Path parameters
Name Description
taggingRuleId*
String
A tagging rule
Required

Responses

Status: 200 - Success

{

A tagging rule

Required: action,condition,name,priority,tagKey,taggingRuleId
taggingRuleId:
string
name:
string
tagKey:
string
description:
string
priority:
integer (int32)
condition:
{
Required: orClauses
orClauses:
[
{
Required: expressions
expressions:
[
{
Required: operator,tagKey,value
tagKey:
string
operator:
string
Enum: EQUALS, MATCHESPATTERN
value:
string
}
]
}
]
}
action:
{
Required: type
type:
string
}
}

Status: 400 - ApiBadRequest

{

Invalid request

message:
string

Description of the error

fields:
[

Any fields/values that are invalid or incorrect

string

Any fields/values that are invalid or incorrect

]
}

Status: 401 - ApiUnauthorized

{

Authorization failed

message:
string
}

Status: 403 - ApiForbidden

{

Authorization failed

message:
string
}

Status: 404 - ApiNotFound

{

A resource or required component was not found

Required: message
message:
string

Name of the resource

description:
string

Violation description

fields:
[

Any fields/values that weren't found

string

Any fields/values that weren't found

]
}

listSystemTagKey

List system-provided tag keys used in tagging rules


/public/api/v1/systemTagKey

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"//public/api/v1/systemTagKey"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TaggingRuleServiceApi;

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

public class TaggingRuleServiceApiExample {

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

public class TaggingRuleServiceApiExample {

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

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

[apiInstance listSystemTagKeyWithCompletionHandler: 
              ^(array[SystemTagKey] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var StarburstControlPlanePublicApi = require('starburst_control_plane_public_api');

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

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

            var apiInstance = new TaggingRuleServiceApi();

            try
            {
                array[SystemTagKey] result = apiInstance.listSystemTagKey();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TaggingRuleServiceApi.listSystemTagKey: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

try: 
    api_response = api_instance.list_system_tag_key()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TaggingRuleServiceApi->listSystemTagKey: %s\n" % e)

Parameters

Responses

Status: 200 - Success

[

A system-provided query tag key

{

A system-provided query tag key

Required: key
key:
string
}
]

Status: 400 - ApiBadRequest

{

Invalid request

message:
string

Description of the error

fields:
[

Any fields/values that are invalid or incorrect

string

Any fields/values that are invalid or incorrect

]
}

Status: 401 - ApiUnauthorized

{

Authorization failed

message:
string
}

Status: 403 - ApiForbidden

{

Authorization failed

message:
string
}

Status: 404 - ApiNotFound

{

A resource or required component was not found

Required: message
message:
string

Name of the resource

description:
string

Violation description

fields:
[

Any fields/values that weren't found

string

Any fields/values that weren't found

]
}

listTaggingRule

List all tagging rules


/public/api/v1/taggingRule

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"//public/api/v1/taggingRule"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TaggingRuleServiceApi;

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

public class TaggingRuleServiceApiExample {

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

public class TaggingRuleServiceApiExample {

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

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

[apiInstance listTaggingRuleWithCompletionHandler: 
              ^(PaginatedTaggingRule output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var StarburstControlPlanePublicApi = require('starburst_control_plane_public_api');

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

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

            var apiInstance = new TaggingRuleServiceApi();

            try
            {
                PaginatedTaggingRule result = apiInstance.listTaggingRule();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TaggingRuleServiceApi.listTaggingRule: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

try: 
    api_response = api_instance.list_tagging_rule()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TaggingRuleServiceApi->listTaggingRule: %s\n" % e)

Parameters

Responses

Status: 200 - Success

{
nextPageToken:
string

The next page token to use or "" if there are no more pages.

result:
[

A page of results.

{

A tagging rule

Required: action,condition,name,priority,tagKey,taggingRuleId
taggingRuleId:
string
name:
string
tagKey:
string
description:
string
priority:
integer (int32)
condition:
{
Required: orClauses
orClauses:
[
{
Required: expressions
expressions:
[
{
Required: operator,tagKey,value
tagKey:
string
operator:
string
Enum: EQUALS, MATCHESPATTERN
value:
string
}
]
}
]
}
action:
{
Required: type
type:
string
}
}
]
}

Status: 400 - ApiBadRequest

{

Invalid request

message:
string

Description of the error

fields:
[

Any fields/values that are invalid or incorrect

string

Any fields/values that are invalid or incorrect

]
}

Status: 401 - ApiUnauthorized

{

Authorization failed

message:
string
}

Status: 403 - ApiForbidden

{

Authorization failed

message:
string
}

Status: 404 - ApiNotFound

{

A resource or required component was not found

Required: message
message:
string

Name of the resource

description:
string

Violation description

fields:
[

Any fields/values that weren't found

string

Any fields/values that weren't found

]
}

updateTaggingRule

Update a tagging rule


/public/api/v1/taggingRule/{taggingRuleId}

Usage and SDK Samples

curl -X PUT\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"//public/api/v1/taggingRule/{taggingRuleId}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TaggingRuleServiceApi;

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

public class TaggingRuleServiceApiExample {

    public static void main(String[] args) {
        
        TaggingRuleServiceApi apiInstance = new TaggingRuleServiceApi();
        TaggingRuleAttributes body = ; // TaggingRuleAttributes | 
        String taggingRuleId = taggingRuleId_example; // String | A tagging rule
        try {
            TaggingRule result = apiInstance.updateTaggingRule(body, taggingRuleId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TaggingRuleServiceApi#updateTaggingRule");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.TaggingRuleServiceApi;

public class TaggingRuleServiceApiExample {

    public static void main(String[] args) {
        TaggingRuleServiceApi apiInstance = new TaggingRuleServiceApi();
        TaggingRuleAttributes body = ; // TaggingRuleAttributes | 
        String taggingRuleId = taggingRuleId_example; // String | A tagging rule
        try {
            TaggingRule result = apiInstance.updateTaggingRule(body, taggingRuleId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TaggingRuleServiceApi#updateTaggingRule");
            e.printStackTrace();
        }
    }
}
TaggingRuleAttributes *body = ; // 
String *taggingRuleId = taggingRuleId_example; // A tagging rule

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

[apiInstance updateTaggingRuleWith:body
    taggingRuleId:taggingRuleId
              completionHandler: ^(TaggingRule output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var StarburstControlPlanePublicApi = require('starburst_control_plane_public_api');

var api = new StarburstControlPlanePublicApi.TaggingRuleServiceApi()
var body = ; // {{TaggingRuleAttributes}} 
var taggingRuleId = taggingRuleId_example; // {{String}} A tagging rule

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

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

            var apiInstance = new TaggingRuleServiceApi();
            var body = new TaggingRuleAttributes(); // TaggingRuleAttributes | 
            var taggingRuleId = taggingRuleId_example;  // String | A tagging rule

            try
            {
                TaggingRule result = apiInstance.updateTaggingRule(body, taggingRuleId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TaggingRuleServiceApi.updateTaggingRule: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiTaggingRuleServiceApi();
$body = ; // TaggingRuleAttributes | 
$taggingRuleId = taggingRuleId_example; // String | A tagging rule

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

my $api_instance = WWW::SwaggerClient::TaggingRuleServiceApi->new();
my $body = WWW::SwaggerClient::Object::TaggingRuleAttributes->new(); # TaggingRuleAttributes | 
my $taggingRuleId = taggingRuleId_example; # String | A tagging rule

eval { 
    my $result = $api_instance->updateTaggingRule(body => $body, taggingRuleId => $taggingRuleId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TaggingRuleServiceApi->updateTaggingRule: $@\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.TaggingRuleServiceApi()
body =  # TaggingRuleAttributes | 
taggingRuleId = taggingRuleId_example # String | A tagging rule

try: 
    api_response = api_instance.update_tagging_rule(body, taggingRuleId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TaggingRuleServiceApi->updateTaggingRule: %s\n" % e)

Parameters

Path parameters
Name Description
taggingRuleId*
String
A tagging rule
Required
Body parameters
Name Description
body *
{

Attributes for creating or updating a tagging rule

Required: action,condition,name,priority,tagKey
name:
string
tagKey:
string
description:
string
priority:
integer (int32)
condition:
{
Required: orClauses
orClauses:
}
action:
{
Required: type
type:
}
}

Responses

Status: 200 - Success

{

A tagging rule

Required: action,condition,name,priority,tagKey,taggingRuleId
taggingRuleId:
string
name:
string
tagKey:
string
description:
string
priority:
integer (int32)
condition:
{
Required: orClauses
orClauses:
[
{
Required: expressions
expressions:
[
{
Required: operator,tagKey,value
tagKey:
string
operator:
string
Enum: EQUALS, MATCHESPATTERN
value:
string
}
]
}
]
}
action:
{
Required: type
type:
string
}
}

Status: 400 - ApiBadRequest

{

Invalid request

message:
string

Description of the error

fields:
[

Any fields/values that are invalid or incorrect

string

Any fields/values that are invalid or incorrect

]
}

Status: 401 - ApiUnauthorized

{

Authorization failed

message:
string
}

Status: 403 - ApiForbidden

{

Authorization failed

message:
string
}

Status: 409 - ApiAlreadyExists

{

Already exists

message:
string
}

Status: 404 - ApiNotFound

{

A resource or required component was not found

Required: message
message:
string

Name of the resource

description:
string

Violation description

fields:
[

Any fields/values that weren't found

string

Any fields/values that weren't found

]
}