WaveRunner API

Blockstorage

blockstorageFilenamePut

Add blockstorage

Adds a blockstorage


/blockstorage/{filename}

Usage and SDK Samples

curl -X PUT "https://api.tidalscale.com/v1/blockstorage/{filename}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.BlockstorageApi;

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

public class BlockstorageApiExample {

    public static void main(String[] args) {
        
        BlockstorageApi apiInstance = new BlockstorageApi();
        String filename = filename_example; // String | name of file
        try {
            apiInstance.blockstorageFilenamePut(filename);
        } catch (ApiException e) {
            System.err.println("Exception when calling BlockstorageApi#blockstorageFilenamePut");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.BlockstorageApi;

public class BlockstorageApiExample {

    public static void main(String[] args) {
        BlockstorageApi apiInstance = new BlockstorageApi();
        String filename = filename_example; // String | name of file
        try {
            apiInstance.blockstorageFilenamePut(filename);
        } catch (ApiException e) {
            System.err.println("Exception when calling BlockstorageApi#blockstorageFilenamePut");
            e.printStackTrace();
        }
    }
}
String *filename = filename_example; // name of file

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

// Add blockstorage
[apiInstance blockstorageFilenamePutWith:filename
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WaveRunnerApi = require('wave_runner_api');

var api = new WaveRunnerApi.BlockstorageApi()

var filename = filename_example; // {String} name of file


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

namespace Example
{
    public class blockstorageFilenamePutExample
    {
        public void main()
        {
            
            var apiInstance = new BlockstorageApi();
            var filename = filename_example;  // String | name of file

            try
            {
                // Add blockstorage
                apiInstance.blockstorageFilenamePut(filename);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BlockstorageApi.blockstorageFilenamePut: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\BlockstorageApi();
$filename = filename_example; // String | name of file

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

my $api_instance = WWW::SwaggerClient::BlockstorageApi->new();
my $filename = filename_example; # String | name of file

eval { 
    $api_instance->blockstorageFilenamePut(filename => $filename);
};
if ($@) {
    warn "Exception when calling BlockstorageApi->blockstorageFilenamePut: $@\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.BlockstorageApi()
filename = filename_example # String | name of file

try: 
    # Add blockstorage
    api_instance.blockstorage_filename_put(filename)
except ApiException as e:
    print("Exception when calling BlockstorageApi->blockstorageFilenamePut: %s\n" % e)

Parameters

Path parameters
Name Description
filename*
String
name of file
Required

Responses

Status: 200 - OK

Status: 500 - Internal Server Error


blockstorageGet

Get blockstorage

Returns updated list of blockstorage available


/blockstorage

Usage and SDK Samples

curl -X GET "https://api.tidalscale.com/v1/blockstorage"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.BlockstorageApi;

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

public class BlockstorageApiExample {

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

public class BlockstorageApiExample {

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

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

// Get blockstorage
[apiInstance blockstorageGetWithCompletionHandler: 
              ^(array[inline_response_200_7] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WaveRunnerApi = require('wave_runner_api');

var api = new WaveRunnerApi.BlockstorageApi()

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

namespace Example
{
    public class blockstorageGetExample
    {
        public void main()
        {
            
            var apiInstance = new BlockstorageApi();

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

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

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

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

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

try: 
    # Get blockstorage
    api_response = api_instance.blockstorage_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BlockstorageApi->blockstorageGet: %s\n" % e)

Parameters

Responses

Status: 200 - successfully found and updated list of blockstorage

Status: 404 - Blockstorage not found

Status: 500 - Internal Server Error


Console

getGuestConsoleWebSocket

WebSocket to connect to guest shell

streams the websocket to a new guest shell connection.


/pools/{poolId}/pods/{podId}/ws/guestconsole

Usage and SDK Samples

curl -X GET "https://api.tidalscale.com/v1/pools/{poolId}/pods/{podId}/ws/guestconsole"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ConsoleApi;

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

public class ConsoleApiExample {

    public static void main(String[] args) {
        
        ConsoleApi apiInstance = new ConsoleApi();
        String poolId = poolId_example; // String | The ID of the desired TidalPool containing this TidalPod
        String podId = podId_example; // String | The ID of the desired TidalPod connect to guest console
        try {
            apiInstance.getGuestConsoleWebSocket(poolId, podId);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConsoleApi#getGuestConsoleWebSocket");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ConsoleApi;

public class ConsoleApiExample {

    public static void main(String[] args) {
        ConsoleApi apiInstance = new ConsoleApi();
        String poolId = poolId_example; // String | The ID of the desired TidalPool containing this TidalPod
        String podId = podId_example; // String | The ID of the desired TidalPod connect to guest console
        try {
            apiInstance.getGuestConsoleWebSocket(poolId, podId);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConsoleApi#getGuestConsoleWebSocket");
            e.printStackTrace();
        }
    }
}
String *poolId = poolId_example; // The ID of the desired TidalPool containing this TidalPod
String *podId = podId_example; // The ID of the desired TidalPod connect to guest console

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

// WebSocket to connect to guest shell
[apiInstance getGuestConsoleWebSocketWith:poolId
    podId:podId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WaveRunnerApi = require('wave_runner_api');

var api = new WaveRunnerApi.ConsoleApi()

var poolId = poolId_example; // {String} The ID of the desired TidalPool containing this TidalPod

var podId = podId_example; // {String} The ID of the desired TidalPod connect to guest console


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

namespace Example
{
    public class getGuestConsoleWebSocketExample
    {
        public void main()
        {
            
            var apiInstance = new ConsoleApi();
            var poolId = poolId_example;  // String | The ID of the desired TidalPool containing this TidalPod
            var podId = podId_example;  // String | The ID of the desired TidalPod connect to guest console

            try
            {
                // WebSocket to connect to guest shell
                apiInstance.getGuestConsoleWebSocket(poolId, podId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ConsoleApi.getGuestConsoleWebSocket: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\ConsoleApi();
$poolId = poolId_example; // String | The ID of the desired TidalPool containing this TidalPod
$podId = podId_example; // String | The ID of the desired TidalPod connect to guest console

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

my $api_instance = WWW::SwaggerClient::ConsoleApi->new();
my $poolId = poolId_example; # String | The ID of the desired TidalPool containing this TidalPod
my $podId = podId_example; # String | The ID of the desired TidalPod connect to guest console

eval { 
    $api_instance->getGuestConsoleWebSocket(poolId => $poolId, podId => $podId);
};
if ($@) {
    warn "Exception when calling ConsoleApi->getGuestConsoleWebSocket: $@\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.ConsoleApi()
poolId = poolId_example # String | The ID of the desired TidalPool containing this TidalPod
podId = podId_example # String | The ID of the desired TidalPod connect to guest console

try: 
    # WebSocket to connect to guest shell
    api_instance.get_guest_console_web_socket(poolId, podId)
except ApiException as e:
    print("Exception when calling ConsoleApi->getGuestConsoleWebSocket: %s\n" % e)

Parameters

Path parameters
Name Description
poolId*
String
The ID of the desired TidalPool containing this TidalPod
Required
podId*
String
The ID of the desired TidalPod connect to guest console
Required

Responses

Status: 200 - OK

Status: 404 - No guest console found

Status: 500 - Internal Server Error


getNodeConsWsHandler

WebSocket to connect to node console

streams the websocket to a node console.


/pools/{poolId}/pods/{podId}/nodes/{nodeId}/ws/console

Usage and SDK Samples

curl -X GET "https://api.tidalscale.com/v1/pools/{poolId}/pods/{podId}/nodes/{nodeId}/ws/console"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ConsoleApi;

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

public class ConsoleApiExample {

    public static void main(String[] args) {
        
        ConsoleApi apiInstance = new ConsoleApi();
        String poolId = poolId_example; // String | The ID of the desired TidalPool containing this TidalPod
        String podId = podId_example; // String | The ID of the desired TidalPod containing this Node
        String nodeId = nodeId_example; // String | The ID of the desired Node
        try {
            apiInstance.getNodeConsWsHandler(poolId, podId, nodeId);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConsoleApi#getNodeConsWsHandler");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ConsoleApi;

public class ConsoleApiExample {

    public static void main(String[] args) {
        ConsoleApi apiInstance = new ConsoleApi();
        String poolId = poolId_example; // String | The ID of the desired TidalPool containing this TidalPod
        String podId = podId_example; // String | The ID of the desired TidalPod containing this Node
        String nodeId = nodeId_example; // String | The ID of the desired Node
        try {
            apiInstance.getNodeConsWsHandler(poolId, podId, nodeId);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConsoleApi#getNodeConsWsHandler");
            e.printStackTrace();
        }
    }
}
String *poolId = poolId_example; // The ID of the desired TidalPool containing this TidalPod
String *podId = podId_example; // The ID of the desired TidalPod containing this Node
String *nodeId = nodeId_example; // The ID of the desired Node

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

// WebSocket to connect to node console
[apiInstance getNodeConsWsHandlerWith:poolId
    podId:podId
    nodeId:nodeId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WaveRunnerApi = require('wave_runner_api');

var api = new WaveRunnerApi.ConsoleApi()

var poolId = poolId_example; // {String} The ID of the desired TidalPool containing this TidalPod

var podId = podId_example; // {String} The ID of the desired TidalPod containing this Node

var nodeId = nodeId_example; // {String} The ID of the desired Node


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

namespace Example
{
    public class getNodeConsWsHandlerExample
    {
        public void main()
        {
            
            var apiInstance = new ConsoleApi();
            var poolId = poolId_example;  // String | The ID of the desired TidalPool containing this TidalPod
            var podId = podId_example;  // String | The ID of the desired TidalPod containing this Node
            var nodeId = nodeId_example;  // String | The ID of the desired Node

            try
            {
                // WebSocket to connect to node console
                apiInstance.getNodeConsWsHandler(poolId, podId, nodeId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ConsoleApi.getNodeConsWsHandler: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\ConsoleApi();
$poolId = poolId_example; // String | The ID of the desired TidalPool containing this TidalPod
$podId = podId_example; // String | The ID of the desired TidalPod containing this Node
$nodeId = nodeId_example; // String | The ID of the desired Node

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

my $api_instance = WWW::SwaggerClient::ConsoleApi->new();
my $poolId = poolId_example; # String | The ID of the desired TidalPool containing this TidalPod
my $podId = podId_example; # String | The ID of the desired TidalPod containing this Node
my $nodeId = nodeId_example; # String | The ID of the desired Node

eval { 
    $api_instance->getNodeConsWsHandler(poolId => $poolId, podId => $podId, nodeId => $nodeId);
};
if ($@) {
    warn "Exception when calling ConsoleApi->getNodeConsWsHandler: $@\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.ConsoleApi()
poolId = poolId_example # String | The ID of the desired TidalPool containing this TidalPod
podId = podId_example # String | The ID of the desired TidalPod containing this Node
nodeId = nodeId_example # String | The ID of the desired Node

try: 
    # WebSocket to connect to node console
    api_instance.get_node_cons_ws_handler(poolId, podId, nodeId)
except ApiException as e:
    print("Exception when calling ConsoleApi->getNodeConsWsHandler: %s\n" % e)

Parameters

Path parameters
Name Description
poolId*
String
The ID of the desired TidalPool containing this TidalPod
Required
podId*
String
The ID of the desired TidalPod containing this Node
Required
nodeId*
String
The ID of the desired Node
Required

Responses

Status: 200 - OK

Status: 404 - Console not found

Status: 500 - Internal Server Error


getPodConsolesWebSocket

WebSocket to connect to consoles of the nodes in the TidalPod

Streams a read-only websocket to the TidalPod Node consoles to identify boot issues.


/pools/{poolId}/pods/{podId}/ws/consoles

Usage and SDK Samples

curl -X GET "https://api.tidalscale.com/v1/pools/{poolId}/pods/{podId}/ws/consoles"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ConsoleApi;

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

public class ConsoleApiExample {

    public static void main(String[] args) {
        
        ConsoleApi apiInstance = new ConsoleApi();
        String poolId = poolId_example; // String | The ID of the desired TidalPool containing this TidalPod
        String podId = podId_example; // String | The ID of the desired TidalPod connect to the consoles
        try {
            apiInstance.getPodConsolesWebSocket(poolId, podId);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConsoleApi#getPodConsolesWebSocket");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ConsoleApi;

public class ConsoleApiExample {

    public static void main(String[] args) {
        ConsoleApi apiInstance = new ConsoleApi();
        String poolId = poolId_example; // String | The ID of the desired TidalPool containing this TidalPod
        String podId = podId_example; // String | The ID of the desired TidalPod connect to the consoles
        try {
            apiInstance.getPodConsolesWebSocket(poolId, podId);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConsoleApi#getPodConsolesWebSocket");
            e.printStackTrace();
        }
    }
}
String *poolId = poolId_example; // The ID of the desired TidalPool containing this TidalPod
String *podId = podId_example; // The ID of the desired TidalPod connect to the consoles

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

// WebSocket to connect to consoles of the nodes in the TidalPod
[apiInstance getPodConsolesWebSocketWith:poolId
    podId:podId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WaveRunnerApi = require('wave_runner_api');

var api = new WaveRunnerApi.ConsoleApi()

var poolId = poolId_example; // {String} The ID of the desired TidalPool containing this TidalPod

var podId = podId_example; // {String} The ID of the desired TidalPod connect to the consoles


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

namespace Example
{
    public class getPodConsolesWebSocketExample
    {
        public void main()
        {
            
            var apiInstance = new ConsoleApi();
            var poolId = poolId_example;  // String | The ID of the desired TidalPool containing this TidalPod
            var podId = podId_example;  // String | The ID of the desired TidalPod connect to the consoles

            try
            {
                // WebSocket to connect to consoles of the nodes in the TidalPod
                apiInstance.getPodConsolesWebSocket(poolId, podId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ConsoleApi.getPodConsolesWebSocket: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\ConsoleApi();
$poolId = poolId_example; // String | The ID of the desired TidalPool containing this TidalPod
$podId = podId_example; // String | The ID of the desired TidalPod connect to the consoles

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

my $api_instance = WWW::SwaggerClient::ConsoleApi->new();
my $poolId = poolId_example; # String | The ID of the desired TidalPool containing this TidalPod
my $podId = podId_example; # String | The ID of the desired TidalPod connect to the consoles

eval { 
    $api_instance->getPodConsolesWebSocket(poolId => $poolId, podId => $podId);
};
if ($@) {
    warn "Exception when calling ConsoleApi->getPodConsolesWebSocket: $@\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.ConsoleApi()
poolId = poolId_example # String | The ID of the desired TidalPool containing this TidalPod
podId = podId_example # String | The ID of the desired TidalPod connect to the consoles

try: 
    # WebSocket to connect to consoles of the nodes in the TidalPod
    api_instance.get_pod_consoles_web_socket(poolId, podId)
except ApiException as e:
    print("Exception when calling ConsoleApi->getPodConsolesWebSocket: %s\n" % e)

Parameters

Path parameters
Name Description
poolId*
String
The ID of the desired TidalPool containing this TidalPod
Required
podId*
String
The ID of the desired TidalPod connect to the consoles
Required

Responses

Status: 200 - OK

Status: 404 - No console found

Status: 500 - Internal Server Error


Events

getEventsWebSocket

WebSocket to receive alerts on events, logs and tasks.


/ws/events

Usage and SDK Samples

curl -X GET "https://api.tidalscale.com/v1/ws/events"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.EventsApi;

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

public class EventsApiExample {

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

public class EventsApiExample {

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

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

// WebSocket to receive alerts on events, logs and tasks.
[apiInstance getEventsWebSocketWithCompletionHandler: 
              ^(inline_response_200_5 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WaveRunnerApi = require('wave_runner_api');

var api = new WaveRunnerApi.EventsApi()

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

namespace Example
{
    public class getEventsWebSocketExample
    {
        public void main()
        {
            
            var apiInstance = new EventsApi();

            try
            {
                // WebSocket to receive alerts on events, logs and tasks.
                inline_response_200_5 result = apiInstance.getEventsWebSocket();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling EventsApi.getEventsWebSocket: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

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

try: 
    # WebSocket to receive alerts on events, logs and tasks.
    api_response = api_instance.get_events_web_socket()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EventsApi->getEventsWebSocket: %s\n" % e)

Parameters

Responses

Status: 200 - Notification event

Status: 201 - Asynchronous event structure

Status: 202 - Task status message structure

Status: 500 - Internal Server Error


Nodes

addNode

Add a Node to a TidalPod

`nodeId` is a UUID.


/pools/{poolId}/pods/{podId}/nodes

Usage and SDK Samples

curl -X POST "https://api.tidalscale.com/v1/pools/{poolId}/pods/{podId}/nodes"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.NodesApi;

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

public class NodesApiExample {

    public static void main(String[] args) {
        
        NodesApi apiInstance = new NodesApi();
        String poolId = poolId_example; // String | The ID of the desired TidalPool containing this TidalPod
        String podId = podId_example; // String | The ID of the desired TidalPod to add a Node to
        NodeId nodeId = ; // NodeId | `nodeId` is a UUID.

        try {
            array[inline_response_200_1] result = apiInstance.addNode(poolId, podId, nodeId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling NodesApi#addNode");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.NodesApi;

public class NodesApiExample {

    public static void main(String[] args) {
        NodesApi apiInstance = new NodesApi();
        String poolId = poolId_example; // String | The ID of the desired TidalPool containing this TidalPod
        String podId = podId_example; // String | The ID of the desired TidalPod to add a Node to
        NodeId nodeId = ; // NodeId | `nodeId` is a UUID.

        try {
            array[inline_response_200_1] result = apiInstance.addNode(poolId, podId, nodeId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling NodesApi#addNode");
            e.printStackTrace();
        }
    }
}
String *poolId = poolId_example; // The ID of the desired TidalPool containing this TidalPod
String *podId = podId_example; // The ID of the desired TidalPod to add a Node to
NodeId *nodeId = ; // `nodeId` is a UUID.


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

// Add a Node to a TidalPod
[apiInstance addNodeWith:poolId
    podId:podId
    nodeId:nodeId
              completionHandler: ^(array[inline_response_200_1] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WaveRunnerApi = require('wave_runner_api');

var api = new WaveRunnerApi.NodesApi()

var poolId = poolId_example; // {String} The ID of the desired TidalPool containing this TidalPod

var podId = podId_example; // {String} The ID of the desired TidalPod to add a Node to

var nodeId = ; // {NodeId} `nodeId` is a UUID.



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

namespace Example
{
    public class addNodeExample
    {
        public void main()
        {
            
            var apiInstance = new NodesApi();
            var poolId = poolId_example;  // String | The ID of the desired TidalPool containing this TidalPod
            var podId = podId_example;  // String | The ID of the desired TidalPod to add a Node to
            var nodeId = new NodeId(); // NodeId | `nodeId` is a UUID.


            try
            {
                // Add a Node to a TidalPod
                array[inline_response_200_1] result = apiInstance.addNode(poolId, podId, nodeId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling NodesApi.addNode: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\NodesApi();
$poolId = poolId_example; // String | The ID of the desired TidalPool containing this TidalPod
$podId = podId_example; // String | The ID of the desired TidalPod to add a Node to
$nodeId = ; // NodeId | `nodeId` is a UUID.


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

my $api_instance = WWW::SwaggerClient::NodesApi->new();
my $poolId = poolId_example; # String | The ID of the desired TidalPool containing this TidalPod
my $podId = podId_example; # String | The ID of the desired TidalPod to add a Node to
my $nodeId = WWW::SwaggerClient::Object::NodeId->new(); # NodeId | `nodeId` is a UUID.


eval { 
    my $result = $api_instance->addNode(poolId => $poolId, podId => $podId, nodeId => $nodeId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling NodesApi->addNode: $@\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.NodesApi()
poolId = poolId_example # String | The ID of the desired TidalPool containing this TidalPod
podId = podId_example # String | The ID of the desired TidalPod to add a Node to
nodeId =  # NodeId | `nodeId` is a UUID.


try: 
    # Add a Node to a TidalPod
    api_response = api_instance.add_node(poolId, podId, nodeId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NodesApi->addNode: %s\n" % e)

Parameters

Path parameters
Name Description
poolId*
String
The ID of the desired TidalPool containing this TidalPod
Required
podId*
String
The ID of the desired TidalPod to add a Node to
Required
Body parameters
Name Description
nodeId *

Responses

Status: 201 - Node Added

Status: 500 - Internal Server Error


getAllNodes

List all the nodes in the TidalPool


/pools/{poolId}/allnodes

Usage and SDK Samples

curl -X GET "https://api.tidalscale.com/v1/pools/{poolId}/allnodes"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.NodesApi;

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

public class NodesApiExample {

    public static void main(String[] args) {
        
        NodesApi apiInstance = new NodesApi();
        String poolId = poolId_example; // String | The ID of the desired TidalPool
        try {
            array[inline_response_200_1] result = apiInstance.getAllNodes(poolId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling NodesApi#getAllNodes");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.NodesApi;

public class NodesApiExample {

    public static void main(String[] args) {
        NodesApi apiInstance = new NodesApi();
        String poolId = poolId_example; // String | The ID of the desired TidalPool
        try {
            array[inline_response_200_1] result = apiInstance.getAllNodes(poolId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling NodesApi#getAllNodes");
            e.printStackTrace();
        }
    }
}
String *poolId = poolId_example; // The ID of the desired TidalPool

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

// List all the nodes in the TidalPool
[apiInstance getAllNodesWith:poolId
              completionHandler: ^(array[inline_response_200_1] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WaveRunnerApi = require('wave_runner_api');

var api = new WaveRunnerApi.NodesApi()

var poolId = poolId_example; // {String} The ID of the desired TidalPool


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

namespace Example
{
    public class getAllNodesExample
    {
        public void main()
        {
            
            var apiInstance = new NodesApi();
            var poolId = poolId_example;  // String | The ID of the desired TidalPool

            try
            {
                // List all the nodes in the TidalPool
                array[inline_response_200_1] result = apiInstance.getAllNodes(poolId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling NodesApi.getAllNodes: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\NodesApi();
$poolId = poolId_example; // String | The ID of the desired TidalPool

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

my $api_instance = WWW::SwaggerClient::NodesApi->new();
my $poolId = poolId_example; # String | The ID of the desired TidalPool

eval { 
    my $result = $api_instance->getAllNodes(poolId => $poolId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling NodesApi->getAllNodes: $@\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.NodesApi()
poolId = poolId_example # String | The ID of the desired TidalPool

try: 
    # List all the nodes in the TidalPool
    api_response = api_instance.get_all_nodes(poolId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NodesApi->getAllNodes: %s\n" % e)

Parameters

Path parameters
Name Description
poolId*
String
The ID of the desired TidalPool
Required

Responses

Status: 200 - OK

Status: 404 - No Nodes in this TidalPool

Status: 500 - Internal Server Error


getFreeNodes

List the free (available to be added to a TidalPod) Nodes in this TidalPool

**Note:** `nodeId` is a UUID.


/pools/{poolId}/freenodes

Usage and SDK Samples

curl -X GET "https://api.tidalscale.com/v1/pools/{poolId}/freenodes"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.NodesApi;

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

public class NodesApiExample {

    public static void main(String[] args) {
        
        NodesApi apiInstance = new NodesApi();
        String poolId = poolId_example; // String | The ID of the desired TidalPool containing the free Nodes
        try {
            array[inline_response_200_1] result = apiInstance.getFreeNodes(poolId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling NodesApi#getFreeNodes");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.NodesApi;

public class NodesApiExample {

    public static void main(String[] args) {
        NodesApi apiInstance = new NodesApi();
        String poolId = poolId_example; // String | The ID of the desired TidalPool containing the free Nodes
        try {
            array[inline_response_200_1] result = apiInstance.getFreeNodes(poolId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling NodesApi#getFreeNodes");
            e.printStackTrace();
        }
    }
}
String *poolId = poolId_example; // The ID of the desired TidalPool containing the free Nodes

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

// List the free (available to be added to a TidalPod) Nodes in this TidalPool
[apiInstance getFreeNodesWith:poolId
              completionHandler: ^(array[inline_response_200_1] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WaveRunnerApi = require('wave_runner_api');

var api = new WaveRunnerApi.NodesApi()

var poolId = poolId_example; // {String} The ID of the desired TidalPool containing the free Nodes


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

namespace Example
{
    public class getFreeNodesExample
    {
        public void main()
        {
            
            var apiInstance = new NodesApi();
            var poolId = poolId_example;  // String | The ID of the desired TidalPool containing the free Nodes

            try
            {
                // List the free (available to be added to a TidalPod) Nodes in this TidalPool
                array[inline_response_200_1] result = apiInstance.getFreeNodes(poolId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling NodesApi.getFreeNodes: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\NodesApi();
$poolId = poolId_example; // String | The ID of the desired TidalPool containing the free Nodes

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

my $api_instance = WWW::SwaggerClient::NodesApi->new();
my $poolId = poolId_example; # String | The ID of the desired TidalPool containing the free Nodes

eval { 
    my $result = $api_instance->getFreeNodes(poolId => $poolId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling NodesApi->getFreeNodes: $@\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.NodesApi()
poolId = poolId_example # String | The ID of the desired TidalPool containing the free Nodes

try: 
    # List the free (available to be added to a TidalPod) Nodes in this TidalPool
    api_response = api_instance.get_free_nodes(poolId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NodesApi->getFreeNodes: %s\n" % e)

Parameters

Path parameters
Name Description
poolId*
String
The ID of the desired TidalPool containing the free Nodes
Required

Responses

Status: 200 - OK

Status: 404 - No free Nodes in this TidalPool

Status: 500 - Internal Server Error


getNodeConsolePage

Creates node console page


/pools/{poolId}/pods/{podId}/nodes/{nodeId}/console

Usage and SDK Samples

curl -X GET "https://api.tidalscale.com/v1/pools/{poolId}/pods/{podId}/nodes/{nodeId}/console"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.NodesApi;

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

public class NodesApiExample {

    public static void main(String[] args) {
        
        NodesApi apiInstance = new NodesApi();
        String poolId = poolId_example; // String | The ID of the desired TidalPool containing this TidalPod
        String podId = podId_example; // String | The ID of the desired TidalPod containing this Node
        String nodeId = nodeId_example; // String | The ID of the desired Node
        try {
            apiInstance.getNodeConsolePage(poolId, podId, nodeId);
        } catch (ApiException e) {
            System.err.println("Exception when calling NodesApi#getNodeConsolePage");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.NodesApi;

public class NodesApiExample {

    public static void main(String[] args) {
        NodesApi apiInstance = new NodesApi();
        String poolId = poolId_example; // String | The ID of the desired TidalPool containing this TidalPod
        String podId = podId_example; // String | The ID of the desired TidalPod containing this Node
        String nodeId = nodeId_example; // String | The ID of the desired Node
        try {
            apiInstance.getNodeConsolePage(poolId, podId, nodeId);
        } catch (ApiException e) {
            System.err.println("Exception when calling NodesApi#getNodeConsolePage");
            e.printStackTrace();
        }
    }
}
String *poolId = poolId_example; // The ID of the desired TidalPool containing this TidalPod
String *podId = podId_example; // The ID of the desired TidalPod containing this Node
String *nodeId = nodeId_example; // The ID of the desired Node

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

[apiInstance getNodeConsolePageWith:poolId
    podId:podId
    nodeId:nodeId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WaveRunnerApi = require('wave_runner_api');

var api = new WaveRunnerApi.NodesApi()

var poolId = poolId_example; // {String} The ID of the desired TidalPool containing this TidalPod

var podId = podId_example; // {String} The ID of the desired TidalPod containing this Node

var nodeId = nodeId_example; // {String} The ID of the desired Node


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

namespace Example
{
    public class getNodeConsolePageExample
    {
        public void main()
        {
            
            var apiInstance = new NodesApi();
            var poolId = poolId_example;  // String | The ID of the desired TidalPool containing this TidalPod
            var podId = podId_example;  // String | The ID of the desired TidalPod containing this Node
            var nodeId = nodeId_example;  // String | The ID of the desired Node

            try
            {
                apiInstance.getNodeConsolePage(poolId, podId, nodeId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling NodesApi.getNodeConsolePage: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\NodesApi();
$poolId = poolId_example; // String | The ID of the desired TidalPool containing this TidalPod
$podId = podId_example; // String | The ID of the desired TidalPod containing this Node
$nodeId = nodeId_example; // String | The ID of the desired Node

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

my $api_instance = WWW::SwaggerClient::NodesApi->new();
my $poolId = poolId_example; # String | The ID of the desired TidalPool containing this TidalPod
my $podId = podId_example; # String | The ID of the desired TidalPod containing this Node
my $nodeId = nodeId_example; # String | The ID of the desired Node

eval { 
    $api_instance->getNodeConsolePage(poolId => $poolId, podId => $podId, nodeId => $nodeId);
};
if ($@) {
    warn "Exception when calling NodesApi->getNodeConsolePage: $@\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.NodesApi()
poolId = poolId_example # String | The ID of the desired TidalPool containing this TidalPod
podId = podId_example # String | The ID of the desired TidalPod containing this Node
nodeId = nodeId_example # String | The ID of the desired Node

try: 
    api_instance.get_node_console_page(poolId, podId, nodeId)
except ApiException as e:
    print("Exception when calling NodesApi->getNodeConsolePage: %s\n" % e)

Parameters

Path parameters
Name Description
poolId*
String
The ID of the desired TidalPool containing this TidalPod
Required
podId*
String
The ID of the desired TidalPod containing this Node
Required
nodeId*
String
The ID of the desired Node
Required

Responses

Status: 200 - OK

Status: 404 - Console not found

Status: 500 - Internal Server Error


getNodeDetail

Return the details of a Node


/pools/{poolId}/pods/{podId}/nodes/{nodeId}

Usage and SDK Samples

curl -X GET "https://api.tidalscale.com/v1/pools/{poolId}/pods/{podId}/nodes/{nodeId}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.NodesApi;

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

public class NodesApiExample {

    public static void main(String[] args) {
        
        NodesApi apiInstance = new NodesApi();
        String poolId = poolId_example; // String | The ID of the desired TidalPool containing the Node
        String podId = podId_example; // String | The ID of the desired TidalPod containing this Node
        String nodeId = nodeId_example; // String | The ID of the desired Node to return. `nodeId` is a UUID.
        try {
            inline_response_200_1 result = apiInstance.getNodeDetail(poolId, podId, nodeId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling NodesApi#getNodeDetail");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.NodesApi;

public class NodesApiExample {

    public static void main(String[] args) {
        NodesApi apiInstance = new NodesApi();
        String poolId = poolId_example; // String | The ID of the desired TidalPool containing the Node
        String podId = podId_example; // String | The ID of the desired TidalPod containing this Node
        String nodeId = nodeId_example; // String | The ID of the desired Node to return. `nodeId` is a UUID.
        try {
            inline_response_200_1 result = apiInstance.getNodeDetail(poolId, podId, nodeId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling NodesApi#getNodeDetail");
            e.printStackTrace();
        }
    }
}
String *poolId = poolId_example; // The ID of the desired TidalPool containing the Node
String *podId = podId_example; // The ID of the desired TidalPod containing this Node
String *nodeId = nodeId_example; // The ID of the desired Node to return. `nodeId` is a UUID.

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

// Return the details of a Node
[apiInstance getNodeDetailWith:poolId
    podId:podId
    nodeId:nodeId
              completionHandler: ^(inline_response_200_1 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WaveRunnerApi = require('wave_runner_api');

var api = new WaveRunnerApi.NodesApi()

var poolId = poolId_example; // {String} The ID of the desired TidalPool containing the Node

var podId = podId_example; // {String} The ID of the desired TidalPod containing this Node

var nodeId = nodeId_example; // {String} The ID of the desired Node to return. `nodeId` is a UUID.


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

namespace Example
{
    public class getNodeDetailExample
    {
        public void main()
        {
            
            var apiInstance = new NodesApi();
            var poolId = poolId_example;  // String | The ID of the desired TidalPool containing the Node
            var podId = podId_example;  // String | The ID of the desired TidalPod containing this Node
            var nodeId = nodeId_example;  // String | The ID of the desired Node to return. `nodeId` is a UUID.

            try
            {
                // Return the details of a Node
                inline_response_200_1 result = apiInstance.getNodeDetail(poolId, podId, nodeId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling NodesApi.getNodeDetail: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\NodesApi();
$poolId = poolId_example; // String | The ID of the desired TidalPool containing the Node
$podId = podId_example; // String | The ID of the desired TidalPod containing this Node
$nodeId = nodeId_example; // String | The ID of the desired Node to return. `nodeId` is a UUID.

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

my $api_instance = WWW::SwaggerClient::NodesApi->new();
my $poolId = poolId_example; # String | The ID of the desired TidalPool containing the Node
my $podId = podId_example; # String | The ID of the desired TidalPod containing this Node
my $nodeId = nodeId_example; # String | The ID of the desired Node to return. `nodeId` is a UUID.

eval { 
    my $result = $api_instance->getNodeDetail(poolId => $poolId, podId => $podId, nodeId => $nodeId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling NodesApi->getNodeDetail: $@\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.NodesApi()
poolId = poolId_example # String | The ID of the desired TidalPool containing the Node
podId = podId_example # String | The ID of the desired TidalPod containing this Node
nodeId = nodeId_example # String | The ID of the desired Node to return. `nodeId` is a UUID.

try: 
    # Return the details of a Node
    api_response = api_instance.get_node_detail(poolId, podId, nodeId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NodesApi->getNodeDetail: %s\n" % e)

Parameters

Path parameters
Name Description
poolId*
String
The ID of the desired TidalPool containing the Node
Required
podId*
String
The ID of the desired TidalPod containing this Node
Required
nodeId*
String
The ID of the desired Node to return. `nodeId` is a UUID.
Required

Responses

Status: 200 - OK

Status: 404 - Node not found

Status: 500 - Internal Server Error


getNodeQuickstats

Get the Node stats needed for the Wave Runner admin UI

A convenience method that returns the most recently sampled CPU, MEM, DISK, ENE, NET for a Node


/pools/{poolId}/pods/{podId}/nodes/{nodeId}/quickstats

Usage and SDK Samples

curl -X GET "https://api.tidalscale.com/v1/pools/{poolId}/pods/{podId}/nodes/{nodeId}/quickstats"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.NodesApi;

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

public class NodesApiExample {

    public static void main(String[] args) {
        
        NodesApi apiInstance = new NodesApi();
        String poolId = poolId_example; // String | The ID of the desired TidalPool containing this TidalPod
        String podId = podId_example; // String | The ID of the desired TidalPod containing this Node
        String nodeId = nodeId_example; // String | The ID of the desired Node
        try {
            poolspoolIdpods_podQuickstats result = apiInstance.getNodeQuickstats(poolId, podId, nodeId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling NodesApi#getNodeQuickstats");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.NodesApi;

public class NodesApiExample {

    public static void main(String[] args) {
        NodesApi apiInstance = new NodesApi();
        String poolId = poolId_example; // String | The ID of the desired TidalPool containing this TidalPod
        String podId = podId_example; // String | The ID of the desired TidalPod containing this Node
        String nodeId = nodeId_example; // String | The ID of the desired Node
        try {
            poolspoolIdpods_podQuickstats result = apiInstance.getNodeQuickstats(poolId, podId, nodeId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling NodesApi#getNodeQuickstats");
            e.printStackTrace();
        }
    }
}
String *poolId = poolId_example; // The ID of the desired TidalPool containing this TidalPod
String *podId = podId_example; // The ID of the desired TidalPod containing this Node
String *nodeId = nodeId_example; // The ID of the desired Node

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

// Get the Node stats needed for the Wave Runner admin UI
[apiInstance getNodeQuickstatsWith:poolId
    podId:podId
    nodeId:nodeId
              completionHandler: ^(poolspoolIdpods_podQuickstats output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WaveRunnerApi = require('wave_runner_api');

var api = new WaveRunnerApi.NodesApi()

var poolId = poolId_example; // {String} The ID of the desired TidalPool containing this TidalPod

var podId = podId_example; // {String} The ID of the desired TidalPod containing this Node

var nodeId = nodeId_example; // {String} The ID of the desired Node


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

namespace Example
{
    public class getNodeQuickstatsExample
    {
        public void main()
        {
            
            var apiInstance = new NodesApi();
            var poolId = poolId_example;  // String | The ID of the desired TidalPool containing this TidalPod
            var podId = podId_example;  // String | The ID of the desired TidalPod containing this Node
            var nodeId = nodeId_example;  // String | The ID of the desired Node

            try
            {
                // Get the Node stats needed for the Wave Runner admin UI
                poolspoolIdpods_podQuickstats result = apiInstance.getNodeQuickstats(poolId, podId, nodeId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling NodesApi.getNodeQuickstats: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\NodesApi();
$poolId = poolId_example; // String | The ID of the desired TidalPool containing this TidalPod
$podId = podId_example; // String | The ID of the desired TidalPod containing this Node
$nodeId = nodeId_example; // String | The ID of the desired Node

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

my $api_instance = WWW::SwaggerClient::NodesApi->new();
my $poolId = poolId_example; # String | The ID of the desired TidalPool containing this TidalPod
my $podId = podId_example; # String | The ID of the desired TidalPod containing this Node
my $nodeId = nodeId_example; # String | The ID of the desired Node

eval { 
    my $result = $api_instance->getNodeQuickstats(poolId => $poolId, podId => $podId, nodeId => $nodeId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling NodesApi->getNodeQuickstats: $@\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.NodesApi()
poolId = poolId_example # String | The ID of the desired TidalPool containing this TidalPod
podId = podId_example # String | The ID of the desired TidalPod containing this Node
nodeId = nodeId_example # String | The ID of the desired Node

try: 
    # Get the Node stats needed for the Wave Runner admin UI
    api_response = api_instance.get_node_quickstats(poolId, podId, nodeId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NodesApi->getNodeQuickstats: %s\n" % e)

Parameters

Path parameters
Name Description
poolId*
String
The ID of the desired TidalPool containing this TidalPod
Required
podId*
String
The ID of the desired TidalPod containing this Node
Required
nodeId*
String
The ID of the desired Node
Required

Responses

Status: 200 - OK

Status: 404 - Quickstats not found

Status: 500 - Internal Server Error


getNodeShellPage

Creates node shell page


/pools/{poolId}/pods/{podId}/nodes/{nodeId}/shell

Usage and SDK Samples

curl -X GET "https://api.tidalscale.com/v1/pools/{poolId}/pods/{podId}/nodes/{nodeId}/shell"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.NodesApi;

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

public class NodesApiExample {

    public static void main(String[] args) {
        
        NodesApi apiInstance = new NodesApi();
        String poolId = poolId_example; // String | The ID of the desired TidalPool containing this TidalPod
        String podId = podId_example; // String | The ID of the desired TidalPod containing this Node
        String nodeId = nodeId_example; // String | The ID of the desired Node
        try {
            apiInstance.getNodeShellPage(poolId, podId, nodeId);
        } catch (ApiException e) {
            System.err.println("Exception when calling NodesApi#getNodeShellPage");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.NodesApi;

public class NodesApiExample {

    public static void main(String[] args) {
        NodesApi apiInstance = new NodesApi();
        String poolId = poolId_example; // String | The ID of the desired TidalPool containing this TidalPod
        String podId = podId_example; // String | The ID of the desired TidalPod containing this Node
        String nodeId = nodeId_example; // String | The ID of the desired Node
        try {
            apiInstance.getNodeShellPage(poolId, podId, nodeId);
        } catch (ApiException e) {
            System.err.println("Exception when calling NodesApi#getNodeShellPage");
            e.printStackTrace();
        }
    }
}
String *poolId = poolId_example; // The ID of the desired TidalPool containing this TidalPod
String *podId = podId_example; // The ID of the desired TidalPod containing this Node
String *nodeId = nodeId_example; // The ID of the desired Node

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

[apiInstance getNodeShellPageWith:poolId
    podId:podId
    nodeId:nodeId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WaveRunnerApi = require('wave_runner_api');

var api = new WaveRunnerApi.NodesApi()

var poolId = poolId_example; // {String} The ID of the desired TidalPool containing this TidalPod

var podId = podId_example; // {String} The ID of the desired TidalPod containing this Node

var nodeId = nodeId_example; // {String} The ID of the desired Node


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

namespace Example
{
    public class getNodeShellPageExample
    {
        public void main()
        {
            
            var apiInstance = new NodesApi();
            var poolId = poolId_example;  // String | The ID of the desired TidalPool containing this TidalPod
            var podId = podId_example;  // String | The ID of the desired TidalPod containing this Node
            var nodeId = nodeId_example;  // String | The ID of the desired Node

            try
            {
                apiInstance.getNodeShellPage(poolId, podId, nodeId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling NodesApi.getNodeShellPage: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\NodesApi();
$poolId = poolId_example; // String | The ID of the desired TidalPool containing this TidalPod
$podId = podId_example; // String | The ID of the desired TidalPod containing this Node
$nodeId = nodeId_example; // String | The ID of the desired Node

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

my $api_instance = WWW::SwaggerClient::NodesApi->new();
my $poolId = poolId_example; # String | The ID of the desired TidalPool containing this TidalPod
my $podId = podId_example; # String | The ID of the desired TidalPod containing this Node
my $nodeId = nodeId_example; # String | The ID of the desired Node

eval { 
    $api_instance->getNodeShellPage(poolId => $poolId, podId => $podId, nodeId => $nodeId);
};
if ($@) {
    warn "Exception when calling NodesApi->getNodeShellPage: $@\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.NodesApi()
poolId = poolId_example # String | The ID of the desired TidalPool containing this TidalPod
podId = podId_example # String | The ID of the desired TidalPod containing this Node
nodeId = nodeId_example # String | The ID of the desired Node

try: 
    api_instance.get_node_shell_page(poolId, podId, nodeId)
except ApiException as e:
    print("Exception when calling NodesApi->getNodeShellPage: %s\n" % e)

Parameters

Path parameters
Name Description
poolId*
String
The ID of the desired TidalPool containing this TidalPod
Required
podId*
String
The ID of the desired TidalPod containing this Node
Required
nodeId*
String
The ID of the desired Node
Required

Responses

Status: 200 - OK

Status: 404 - Shell not found

Status: 500 - Internal Server Error


getNodes

List the Nodes in a TidalPod


/pools/{poolId}/pods/{podId}/nodes

Usage and SDK Samples

curl -X GET "https://api.tidalscale.com/v1/pools/{poolId}/pods/{podId}/nodes"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.NodesApi;

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

public class NodesApiExample {

    public static void main(String[] args) {
        
        NodesApi apiInstance = new NodesApi();
        String poolId = poolId_example; // String | The ID of the desired TidalPool containing this TidalPod
        String podId = podId_example; // String | The ID of the desired TidalPod containing these Nodes
        try {
            array[inline_response_200_1] result = apiInstance.getNodes(poolId, podId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling NodesApi#getNodes");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.NodesApi;

public class NodesApiExample {

    public static void main(String[] args) {
        NodesApi apiInstance = new NodesApi();
        String poolId = poolId_example; // String | The ID of the desired TidalPool containing this TidalPod
        String podId = podId_example; // String | The ID of the desired TidalPod containing these Nodes
        try {
            array[inline_response_200_1] result = apiInstance.getNodes(poolId, podId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling NodesApi#getNodes");
            e.printStackTrace();
        }
    }
}
String *poolId = poolId_example; // The ID of the desired TidalPool containing this TidalPod
String *podId = podId_example; // The ID of the desired TidalPod containing these Nodes

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

// List the Nodes in a TidalPod
[apiInstance getNodesWith:poolId
    podId:podId
              completionHandler: ^(array[inline_response_200_1] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WaveRunnerApi = require('wave_runner_api');

var api = new WaveRunnerApi.NodesApi()

var poolId = poolId_example; // {String} The ID of the desired TidalPool containing this TidalPod

var podId = podId_example; // {String} The ID of the desired TidalPod containing these Nodes


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

namespace Example
{
    public class getNodesExample
    {
        public void main()
        {
            
            var apiInstance = new NodesApi();
            var poolId = poolId_example;  // String | The ID of the desired TidalPool containing this TidalPod
            var podId = podId_example;  // String | The ID of the desired TidalPod containing these Nodes

            try
            {
                // List the Nodes in a TidalPod
                array[inline_response_200_1] result = apiInstance.getNodes(poolId, podId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling NodesApi.getNodes: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\NodesApi();
$poolId = poolId_example; // String | The ID of the desired TidalPool containing this TidalPod
$podId = podId_example; // String | The ID of the desired TidalPod containing these Nodes

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

my $api_instance = WWW::SwaggerClient::NodesApi->new();
my $poolId = poolId_example; # String | The ID of the desired TidalPool containing this TidalPod
my $podId = podId_example; # String | The ID of the desired TidalPod containing these Nodes

eval { 
    my $result = $api_instance->getNodes(poolId => $poolId, podId => $podId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling NodesApi->getNodes: $@\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.NodesApi()
poolId = poolId_example # String | The ID of the desired TidalPool containing this TidalPod
podId = podId_example # String | The ID of the desired TidalPod containing these Nodes

try: 
    # List the Nodes in a TidalPod
    api_response = api_instance.get_nodes(poolId, podId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NodesApi->getNodes: %s\n" % e)

Parameters

Path parameters
Name Description
poolId*
String
The ID of the desired TidalPool containing this TidalPod
Required
podId*
String
The ID of the desired TidalPod containing these Nodes
Required

Responses

Status: 200 - OK

Status: 404 - No Nodes found for this TidalPod

Status: 500 - Internal Server Error


getSparkline

draws a perfplot for the node


/pools/{poolId}/pods/{podId}/nodes/{nodeId}/perfplot

Usage and SDK Samples

curl -X GET "https://api.tidalscale.com/v1/pools/{poolId}/pods/{podId}/nodes/{nodeId}/perfplot"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.NodesApi;

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

public class NodesApiExample {

    public static void main(String[] args) {
        
        NodesApi apiInstance = new NodesApi();
        String poolId = poolId_example; // String | The ID of the desired TidalPool containing this TidalPod
        String podId = podId_example; // String | The ID of the desired TidalPod containing this Node
        String nodeId = nodeId_example; // String | The ID of the desired Node
        try {
            apiInstance.getSparkline(poolId, podId, nodeId);
        } catch (ApiException e) {
            System.err.println("Exception when calling NodesApi#getSparkline");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.NodesApi;

public class NodesApiExample {

    public static void main(String[] args) {
        NodesApi apiInstance = new NodesApi();
        String poolId = poolId_example; // String | The ID of the desired TidalPool containing this TidalPod
        String podId = podId_example; // String | The ID of the desired TidalPod containing this Node
        String nodeId = nodeId_example; // String | The ID of the desired Node
        try {
            apiInstance.getSparkline(poolId, podId, nodeId);
        } catch (ApiException e) {
            System.err.println("Exception when calling NodesApi#getSparkline");
            e.printStackTrace();
        }
    }
}
String *poolId = poolId_example; // The ID of the desired TidalPool containing this TidalPod
String *podId = podId_example; // The ID of the desired TidalPod containing this Node
String *nodeId = nodeId_example; // The ID of the desired Node

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

[apiInstance getSparklineWith:poolId
    podId:podId
    nodeId:nodeId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WaveRunnerApi = require('wave_runner_api');

var api = new WaveRunnerApi.NodesApi()

var poolId = poolId_example; // {String} The ID of the desired TidalPool containing this TidalPod

var podId = podId_example; // {String} The ID of the desired TidalPod containing this Node

var nodeId = nodeId_example; // {String} The ID of the desired Node


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

namespace Example
{
    public class getSparklineExample
    {
        public void main()
        {
            
            var apiInstance = new NodesApi();
            var poolId = poolId_example;  // String | The ID of the desired TidalPool containing this TidalPod
            var podId = podId_example;  // String | The ID of the desired TidalPod containing this Node
            var nodeId = nodeId_example;  // String | The ID of the desired Node

            try
            {
                apiInstance.getSparkline(poolId, podId, nodeId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling NodesApi.getSparkline: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\NodesApi();
$poolId = poolId_example; // String | The ID of the desired TidalPool containing this TidalPod
$podId = podId_example; // String | The ID of the desired TidalPod containing this Node
$nodeId = nodeId_example; // String | The ID of the desired Node

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

my $api_instance = WWW::SwaggerClient::NodesApi->new();
my $poolId = poolId_example; # String | The ID of the desired TidalPool containing this TidalPod
my $podId = podId_example; # String | The ID of the desired TidalPod containing this Node
my $nodeId = nodeId_example; # String | The ID of the desired Node

eval { 
    $api_instance->getSparkline(poolId => $poolId, podId => $podId, nodeId => $nodeId);
};
if ($@) {
    warn "Exception when calling NodesApi->getSparkline: $@\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.NodesApi()
poolId = poolId_example # String | The ID of the desired TidalPool containing this TidalPod
podId = podId_example # String | The ID of the desired TidalPod containing this Node
nodeId = nodeId_example # String | The ID of the desired Node

try: 
    api_instance.get_sparkline(poolId, podId, nodeId)
except ApiException as e:
    print("Exception when calling NodesApi->getSparkline: %s\n" % e)

Parameters

Path parameters
Name Description
poolId*
String
The ID of the desired TidalPool containing this TidalPod
Required
podId*
String
The ID of the desired TidalPod containing this Node
Required
nodeId*
String
The ID of the desired Node
Required

Responses

Status: 200 - OK

Status: 404 - Perfplot not found

Status: 500 - Internal Server Error


migrateNode

Transfer the current state of one Node to another for high availability migration

Before calling this method, it may be necessary to introduce a new node to the TidalPod via `getFreeNodes`, `addNode`, then call `removeNode` to remove the "old" node from the TidalPod post-migration.


/pools/{poolId}/pods/{podId}/nodes/{sourceNodeId}/migrate/{destinationNodeId}

Usage and SDK Samples

curl -X POST "https://api.tidalscale.com/v1/pools/{poolId}/pods/{podId}/nodes/{sourceNodeId}/migrate/{destinationNodeId}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.NodesApi;

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

public class NodesApiExample {

    public static void main(String[] args) {
        
        NodesApi apiInstance = new NodesApi();
        String poolId = poolId_example; // String | The ID of the desired TidalPool containing the TidalPod
        String podId = podId_example; // String | The ID of the desired TidalPod containing these Nodes
        String sourceNodeId = sourceNodeId_example; // String | The ID of the desired Node to get the settings from. `nodeId` is a UUID.
        String destinationNodeId = destinationNodeId_example; // String | The ID of the desired Node to apply the settings to. `nodeId` is a UUID.
        try {
            inline_response_200_1 result = apiInstance.migrateNode(poolId, podId, sourceNodeId, destinationNodeId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling NodesApi#migrateNode");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.NodesApi;

public class NodesApiExample {

    public static void main(String[] args) {
        NodesApi apiInstance = new NodesApi();
        String poolId = poolId_example; // String | The ID of the desired TidalPool containing the TidalPod
        String podId = podId_example; // String | The ID of the desired TidalPod containing these Nodes
        String sourceNodeId = sourceNodeId_example; // String | The ID of the desired Node to get the settings from. `nodeId` is a UUID.
        String destinationNodeId = destinationNodeId_example; // String | The ID of the desired Node to apply the settings to. `nodeId` is a UUID.
        try {
            inline_response_200_1 result = apiInstance.migrateNode(poolId, podId, sourceNodeId, destinationNodeId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling NodesApi#migrateNode");
            e.printStackTrace();
        }
    }
}
String *poolId = poolId_example; // The ID of the desired TidalPool containing the TidalPod
String *podId = podId_example; // The ID of the desired TidalPod containing these Nodes
String *sourceNodeId = sourceNodeId_example; // The ID of the desired Node to get the settings from. `nodeId` is a UUID.
String *destinationNodeId = destinationNodeId_example; // The ID of the desired Node to apply the settings to. `nodeId` is a UUID.

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

// Transfer the current state of one Node to another for high availability migration
[apiInstance migrateNodeWith:poolId
    podId:podId
    sourceNodeId:sourceNodeId
    destinationNodeId:destinationNodeId
              completionHandler: ^(inline_response_200_1 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WaveRunnerApi = require('wave_runner_api');

var api = new WaveRunnerApi.NodesApi()

var poolId = poolId_example; // {String} The ID of the desired TidalPool containing the TidalPod

var podId = podId_example; // {String} The ID of the desired TidalPod containing these Nodes

var sourceNodeId = sourceNodeId_example; // {String} The ID of the desired Node to get the settings from. `nodeId` is a UUID.

var destinationNodeId = destinationNodeId_example; // {String} The ID of the desired Node to apply the settings to. `nodeId` is a UUID.


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

namespace Example
{
    public class migrateNodeExample
    {
        public void main()
        {
            
            var apiInstance = new NodesApi();
            var poolId = poolId_example;  // String | The ID of the desired TidalPool containing the TidalPod
            var podId = podId_example;  // String | The ID of the desired TidalPod containing these Nodes
            var sourceNodeId = sourceNodeId_example;  // String | The ID of the desired Node to get the settings from. `nodeId` is a UUID.
            var destinationNodeId = destinationNodeId_example;  // String | The ID of the desired Node to apply the settings to. `nodeId` is a UUID.

            try
            {
                // Transfer the current state of one Node to another for high availability migration
                inline_response_200_1 result = apiInstance.migrateNode(poolId, podId, sourceNodeId, destinationNodeId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling NodesApi.migrateNode: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\NodesApi();
$poolId = poolId_example; // String | The ID of the desired TidalPool containing the TidalPod
$podId = podId_example; // String | The ID of the desired TidalPod containing these Nodes
$sourceNodeId = sourceNodeId_example; // String | The ID of the desired Node to get the settings from. `nodeId` is a UUID.
$destinationNodeId = destinationNodeId_example; // String | The ID of the desired Node to apply the settings to. `nodeId` is a UUID.

try {
    $result = $api_instance->migrateNode($poolId, $podId, $sourceNodeId, $destinationNodeId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling NodesApi->migrateNode: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::NodesApi;

my $api_instance = WWW::SwaggerClient::NodesApi->new();
my $poolId = poolId_example; # String | The ID of the desired TidalPool containing the TidalPod
my $podId = podId_example; # String | The ID of the desired TidalPod containing these Nodes
my $sourceNodeId = sourceNodeId_example; # String | The ID of the desired Node to get the settings from. `nodeId` is a UUID.
my $destinationNodeId = destinationNodeId_example; # String | The ID of the desired Node to apply the settings to. `nodeId` is a UUID.

eval { 
    my $result = $api_instance->migrateNode(poolId => $poolId, podId => $podId, sourceNodeId => $sourceNodeId, destinationNodeId => $destinationNodeId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling NodesApi->migrateNode: $@\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.NodesApi()
poolId = poolId_example # String | The ID of the desired TidalPool containing the TidalPod
podId = podId_example # String | The ID of the desired TidalPod containing these Nodes
sourceNodeId = sourceNodeId_example # String | The ID of the desired Node to get the settings from. `nodeId` is a UUID.
destinationNodeId = destinationNodeId_example # String | The ID of the desired Node to apply the settings to. `nodeId` is a UUID.

try: 
    # Transfer the current state of one Node to another for high availability migration
    api_response = api_instance.migrate_node(poolId, podId, sourceNodeId, destinationNodeId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NodesApi->migrateNode: %s\n" % e)

Parameters

Path parameters
Name Description
poolId*
String
The ID of the desired TidalPool containing the TidalPod
Required
podId*
String
The ID of the desired TidalPod containing these Nodes
Required
sourceNodeId*
String
The ID of the desired Node to get the settings from. `nodeId` is a UUID.
Required
destinationNodeId*
String
The ID of the desired Node to apply the settings to. `nodeId` is a UUID.
Required

Responses

Status: 200 - OK

Status: 404 - Unable to migrate Node, one or more required resources not found

Status: 500 - Internal Server Error


patchPoolsPoolIdNodesNodeId

Update a TidalPool node

update TidalPool node using given specifications


/pools/{poolId}/nodes/{nodeId}

Usage and SDK Samples

curl -X PATCH "https://api.tidalscale.com/v1/pools/{poolId}/nodes/{nodeId}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.NodesApi;

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

public class NodesApiExample {

    public static void main(String[] args) {
        
        NodesApi apiInstance = new NodesApi();
        String poolId = poolId_example; // String | ID that belongs to TidalPool
        String nodeId = nodeId_example; // String | ID that belongs to a Node. `nodeId` is a UUID.
        Patch requirement patch requirement = ; // Patch requirement | 
        try {
            apiInstance.patchPoolsPoolIdNodesNodeId(poolId, nodeId, patch requirement);
        } catch (ApiException e) {
            System.err.println("Exception when calling NodesApi#patchPoolsPoolIdNodesNodeId");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.NodesApi;

public class NodesApiExample {

    public static void main(String[] args) {
        NodesApi apiInstance = new NodesApi();
        String poolId = poolId_example; // String | ID that belongs to TidalPool
        String nodeId = nodeId_example; // String | ID that belongs to a Node. `nodeId` is a UUID.
        Patch requirement patch requirement = ; // Patch requirement | 
        try {
            apiInstance.patchPoolsPoolIdNodesNodeId(poolId, nodeId, patch requirement);
        } catch (ApiException e) {
            System.err.println("Exception when calling NodesApi#patchPoolsPoolIdNodesNodeId");
            e.printStackTrace();
        }
    }
}
String *poolId = poolId_example; // ID that belongs to TidalPool
String *nodeId = nodeId_example; // ID that belongs to a Node. `nodeId` is a UUID.
Patch requirement *patch requirement = ; //  (optional)

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

// Update a TidalPool node
[apiInstance patchPoolsPoolIdNodesNodeIdWith:poolId
    nodeId:nodeId
    patch requirement:patch requirement
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WaveRunnerApi = require('wave_runner_api');

var api = new WaveRunnerApi.NodesApi()

var poolId = poolId_example; // {String} ID that belongs to TidalPool

var nodeId = nodeId_example; // {String} ID that belongs to a Node. `nodeId` is a UUID.

var opts = { 
  'patch requirement':  // {Patch requirement} 
};

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

namespace Example
{
    public class patchPoolsPoolIdNodesNodeIdExample
    {
        public void main()
        {
            
            var apiInstance = new NodesApi();
            var poolId = poolId_example;  // String | ID that belongs to TidalPool
            var nodeId = nodeId_example;  // String | ID that belongs to a Node. `nodeId` is a UUID.
            var patch requirement = new Patch requirement(); // Patch requirement |  (optional) 

            try
            {
                // Update a TidalPool node
                apiInstance.patchPoolsPoolIdNodesNodeId(poolId, nodeId, patch requirement);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling NodesApi.patchPoolsPoolIdNodesNodeId: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\NodesApi();
$poolId = poolId_example; // String | ID that belongs to TidalPool
$nodeId = nodeId_example; // String | ID that belongs to a Node. `nodeId` is a UUID.
$patch requirement = ; // Patch requirement | 

try {
    $api_instance->patchPoolsPoolIdNodesNodeId($poolId, $nodeId, $patch requirement);
} catch (Exception $e) {
    echo 'Exception when calling NodesApi->patchPoolsPoolIdNodesNodeId: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::NodesApi;

my $api_instance = WWW::SwaggerClient::NodesApi->new();
my $poolId = poolId_example; # String | ID that belongs to TidalPool
my $nodeId = nodeId_example; # String | ID that belongs to a Node. `nodeId` is a UUID.
my $patch requirement = WWW::SwaggerClient::Object::Patch requirement->new(); # Patch requirement | 

eval { 
    $api_instance->patchPoolsPoolIdNodesNodeId(poolId => $poolId, nodeId => $nodeId, patch requirement => $patch requirement);
};
if ($@) {
    warn "Exception when calling NodesApi->patchPoolsPoolIdNodesNodeId: $@\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.NodesApi()
poolId = poolId_example # String | ID that belongs to TidalPool
nodeId = nodeId_example # String | ID that belongs to a Node. `nodeId` is a UUID.
patch requirement =  # Patch requirement |  (optional)

try: 
    # Update a TidalPool node
    api_instance.patch_pools_pool_id_nodes_node_id(poolId, nodeId, patch requirement=patch requirement)
except ApiException as e:
    print("Exception when calling NodesApi->patchPoolsPoolIdNodesNodeId: %s\n" % e)

Parameters

Path parameters
Name Description
poolId*
String
ID that belongs to TidalPool
Required
nodeId*
String
ID that belongs to a Node. `nodeId` is a UUID.
Required
Body parameters
Name Description
patch requirement

Responses

Status: 200 - Successfully updated node

Status: 400 - Error updating node. Modify values and try again.

Status: 500 - Internal Server Error


postPoolsPoolIdPodsPodIdNodesNodeIdPower

Change Node power state

change the power of the specified node


/pools/{poolId}/pods/{podId}/nodes/{nodeId}/power

Usage and SDK Samples

curl -X POST "https://api.tidalscale.com/v1/pools/{poolId}/pods/{podId}/nodes/{nodeId}/power"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.NodesApi;

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

public class NodesApiExample {

    public static void main(String[] args) {
        
        NodesApi apiInstance = new NodesApi();
        String poolId = poolId_example; // String | ID that belongs to TidalPool
        String podId = podId_example; // String | ID that belongs to a TidalPod
        String nodeId = nodeId_example; // String | ID that belongs to a node
        try {
            apiInstance.postPoolsPoolIdPodsPodIdNodesNodeIdPower(poolId, podId, nodeId);
        } catch (ApiException e) {
            System.err.println("Exception when calling NodesApi#postPoolsPoolIdPodsPodIdNodesNodeIdPower");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.NodesApi;

public class NodesApiExample {

    public static void main(String[] args) {
        NodesApi apiInstance = new NodesApi();
        String poolId = poolId_example; // String | ID that belongs to TidalPool
        String podId = podId_example; // String | ID that belongs to a TidalPod
        String nodeId = nodeId_example; // String | ID that belongs to a node
        try {
            apiInstance.postPoolsPoolIdPodsPodIdNodesNodeIdPower(poolId, podId, nodeId);
        } catch (ApiException e) {
            System.err.println("Exception when calling NodesApi#postPoolsPoolIdPodsPodIdNodesNodeIdPower");
            e.printStackTrace();
        }
    }
}
String *poolId = poolId_example; // ID that belongs to TidalPool
String *podId = podId_example; // ID that belongs to a TidalPod
String *nodeId = nodeId_example; // ID that belongs to a node

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

// Change Node power state
[apiInstance postPoolsPoolIdPodsPodIdNodesNodeIdPowerWith:poolId
    podId:podId
    nodeId:nodeId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WaveRunnerApi = require('wave_runner_api');

var api = new WaveRunnerApi.NodesApi()

var poolId = poolId_example; // {String} ID that belongs to TidalPool

var podId = podId_example; // {String} ID that belongs to a TidalPod

var nodeId = nodeId_example; // {String} ID that belongs to a node


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

namespace Example
{
    public class postPoolsPoolIdPodsPodIdNodesNodeIdPowerExample
    {
        public void main()
        {
            
            var apiInstance = new NodesApi();
            var poolId = poolId_example;  // String | ID that belongs to TidalPool
            var podId = podId_example;  // String | ID that belongs to a TidalPod
            var nodeId = nodeId_example;  // String | ID that belongs to a node

            try
            {
                // Change Node power state
                apiInstance.postPoolsPoolIdPodsPodIdNodesNodeIdPower(poolId, podId, nodeId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling NodesApi.postPoolsPoolIdPodsPodIdNodesNodeIdPower: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\NodesApi();
$poolId = poolId_example; // String | ID that belongs to TidalPool
$podId = podId_example; // String | ID that belongs to a TidalPod
$nodeId = nodeId_example; // String | ID that belongs to a node

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

my $api_instance = WWW::SwaggerClient::NodesApi->new();
my $poolId = poolId_example; # String | ID that belongs to TidalPool
my $podId = podId_example; # String | ID that belongs to a TidalPod
my $nodeId = nodeId_example; # String | ID that belongs to a node

eval { 
    $api_instance->postPoolsPoolIdPodsPodIdNodesNodeIdPower(poolId => $poolId, podId => $podId, nodeId => $nodeId);
};
if ($@) {
    warn "Exception when calling NodesApi->postPoolsPoolIdPodsPodIdNodesNodeIdPower: $@\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.NodesApi()
poolId = poolId_example # String | ID that belongs to TidalPool
podId = podId_example # String | ID that belongs to a TidalPod
nodeId = nodeId_example # String | ID that belongs to a node

try: 
    # Change Node power state
    api_instance.post_pools_pool_id_pods_pod_id_nodes_node_id_power(poolId, podId, nodeId)
except ApiException as e:
    print("Exception when calling NodesApi->postPoolsPoolIdPodsPodIdNodesNodeIdPower: %s\n" % e)

Parameters

Path parameters
Name Description
poolId*
String
ID that belongs to TidalPool
Required
podId*
String
ID that belongs to a TidalPod
Required
nodeId*
String
ID that belongs to a node
Required

Responses

Status: 200 - Successfully changed power (on/off/reset) of the node

Status: 400 - Bad request; must be one of on,off, or reset

Status: 500 - Error creating power task


removeNode

Remove a Node from a TidalPod

Can be used with `addNode` to effectively "Replace Node"


/pools/{poolId}/pods/{podId}/nodes/{nodeId}

Usage and SDK Samples

curl -X DELETE "https://api.tidalscale.com/v1/pools/{poolId}/pods/{podId}/nodes/{nodeId}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.NodesApi;

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

public class NodesApiExample {

    public static void main(String[] args) {
        
        NodesApi apiInstance = new NodesApi();
        String poolId = poolId_example; // String | The ID of the desired TidalPool containing this Node
        String podId = podId_example; // String | The ID of the desired TidalPod containing this Node
        String nodeId = nodeId_example; // String | The ID of the desired Node to remove from the TidalPod. `nodeId` is a UUID.
        try {
            apiInstance.removeNode(poolId, podId, nodeId);
        } catch (ApiException e) {
            System.err.println("Exception when calling NodesApi#removeNode");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.NodesApi;

public class NodesApiExample {

    public static void main(String[] args) {
        NodesApi apiInstance = new NodesApi();
        String poolId = poolId_example; // String | The ID of the desired TidalPool containing this Node
        String podId = podId_example; // String | The ID of the desired TidalPod containing this Node
        String nodeId = nodeId_example; // String | The ID of the desired Node to remove from the TidalPod. `nodeId` is a UUID.
        try {
            apiInstance.removeNode(poolId, podId, nodeId);
        } catch (ApiException e) {
            System.err.println("Exception when calling NodesApi#removeNode");
            e.printStackTrace();
        }
    }
}
String *poolId = poolId_example; // The ID of the desired TidalPool containing this Node
String *podId = podId_example; // The ID of the desired TidalPod containing this Node
String *nodeId = nodeId_example; // The ID of the desired Node to remove from the TidalPod. `nodeId` is a UUID.

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

// Remove a Node from a TidalPod
[apiInstance removeNodeWith:poolId
    podId:podId
    nodeId:nodeId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WaveRunnerApi = require('wave_runner_api');

var api = new WaveRunnerApi.NodesApi()

var poolId = poolId_example; // {String} The ID of the desired TidalPool containing this Node

var podId = podId_example; // {String} The ID of the desired TidalPod containing this Node

var nodeId = nodeId_example; // {String} The ID of the desired Node to remove from the TidalPod. `nodeId` is a UUID.


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

namespace Example
{
    public class removeNodeExample
    {
        public void main()
        {
            
            var apiInstance = new NodesApi();
            var poolId = poolId_example;  // String | The ID of the desired TidalPool containing this Node
            var podId = podId_example;  // String | The ID of the desired TidalPod containing this Node
            var nodeId = nodeId_example;  // String | The ID of the desired Node to remove from the TidalPod. `nodeId` is a UUID.

            try
            {
                // Remove a Node from a TidalPod
                apiInstance.removeNode(poolId, podId, nodeId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling NodesApi.removeNode: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\NodesApi();
$poolId = poolId_example; // String | The ID of the desired TidalPool containing this Node
$podId = podId_example; // String | The ID of the desired TidalPod containing this Node
$nodeId = nodeId_example; // String | The ID of the desired Node to remove from the TidalPod. `nodeId` is a UUID.

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

my $api_instance = WWW::SwaggerClient::NodesApi->new();
my $poolId = poolId_example; # String | The ID of the desired TidalPool containing this Node
my $podId = podId_example; # String | The ID of the desired TidalPod containing this Node
my $nodeId = nodeId_example; # String | The ID of the desired Node to remove from the TidalPod. `nodeId` is a UUID.

eval { 
    $api_instance->removeNode(poolId => $poolId, podId => $podId, nodeId => $nodeId);
};
if ($@) {
    warn "Exception when calling NodesApi->removeNode: $@\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.NodesApi()
poolId = poolId_example # String | The ID of the desired TidalPool containing this Node
podId = podId_example # String | The ID of the desired TidalPod containing this Node
nodeId = nodeId_example # String | The ID of the desired Node to remove from the TidalPod. `nodeId` is a UUID.

try: 
    # Remove a Node from a TidalPod
    api_instance.remove_node(poolId, podId, nodeId)
except ApiException as e:
    print("Exception when calling NodesApi->removeNode: %s\n" % e)

Parameters

Path parameters
Name Description
poolId*
String
The ID of the desired TidalPool containing this Node
Required
podId*
String
The ID of the desired TidalPod containing this Node
Required
nodeId*
String
The ID of the desired Node to remove from the TidalPod. `nodeId` is a UUID.
Required

Responses

Status: 200 - OK

Status: 500 - Internal Server Error


Pods

addPod

Add a TidalPod to a TidalPool

Schema is very similar to `GET /pools/{poolId}/pods`, less `quickStats` and the `*Id` values set at creation After creating a TidalPod, use `addNode` to add available Nodes to it


/pools/{poolId}/pods

Usage and SDK Samples

curl -X POST "https://api.tidalscale.com/v1/pools/{poolId}/pods"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PodsApi;

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

public class PodsApiExample {

    public static void main(String[] args) {
        
        PodsApi apiInstance = new PodsApi();
        String poolId = poolId_example; // String | The ID of the desired TidalPool containing this TidalPod
        Pod pod = ; // Pod | This object represents all the TidalPod settings that can be set at TidalPod creation

        try {
            array[inline_response_200_3] result = apiInstance.addPod(poolId, pod);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PodsApi#addPod");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.PodsApi;

public class PodsApiExample {

    public static void main(String[] args) {
        PodsApi apiInstance = new PodsApi();
        String poolId = poolId_example; // String | The ID of the desired TidalPool containing this TidalPod
        Pod pod = ; // Pod | This object represents all the TidalPod settings that can be set at TidalPod creation

        try {
            array[inline_response_200_3] result = apiInstance.addPod(poolId, pod);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PodsApi#addPod");
            e.printStackTrace();
        }
    }
}
String *poolId = poolId_example; // The ID of the desired TidalPool containing this TidalPod
Pod *pod = ; // This object represents all the TidalPod settings that can be set at TidalPod creation


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

// Add a TidalPod to a TidalPool
[apiInstance addPodWith:poolId
    pod:pod
              completionHandler: ^(array[inline_response_200_3] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WaveRunnerApi = require('wave_runner_api');

var api = new WaveRunnerApi.PodsApi()

var poolId = poolId_example; // {String} The ID of the desired TidalPool containing this TidalPod

var pod = ; // {Pod} This object represents all the TidalPod settings that can be set at TidalPod creation



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

namespace Example
{
    public class addPodExample
    {
        public void main()
        {
            
            var apiInstance = new PodsApi();
            var poolId = poolId_example;  // String | The ID of the desired TidalPool containing this TidalPod
            var pod = new Pod(); // Pod | This object represents all the TidalPod settings that can be set at TidalPod creation


            try
            {
                // Add a TidalPod to a TidalPool
                array[inline_response_200_3] result = apiInstance.addPod(poolId, pod);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PodsApi.addPod: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\PodsApi();
$poolId = poolId_example; // String | The ID of the desired TidalPool containing this TidalPod
$pod = ; // Pod | This object represents all the TidalPod settings that can be set at TidalPod creation


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

my $api_instance = WWW::SwaggerClient::PodsApi->new();
my $poolId = poolId_example; # String | The ID of the desired TidalPool containing this TidalPod
my $pod = WWW::SwaggerClient::Object::Pod->new(); # Pod | This object represents all the TidalPod settings that can be set at TidalPod creation


eval { 
    my $result = $api_instance->addPod(poolId => $poolId, pod => $pod);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PodsApi->addPod: $@\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.PodsApi()
poolId = poolId_example # String | The ID of the desired TidalPool containing this TidalPod
pod =  # Pod | This object represents all the TidalPod settings that can be set at TidalPod creation


try: 
    # Add a TidalPod to a TidalPool
    api_response = api_instance.add_pod(poolId, pod)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PodsApi->addPod: %s\n" % e)

Parameters

Path parameters
Name Description
poolId*
String
The ID of the desired TidalPool containing this TidalPod
Required
Body parameters
Name Description
pod *

Responses

Status: 201 - TidalPod Added

Status: 500 - Internal Server Error


bootPodGuest

Boot or Shutdown TidalPod Guest

Set status `boolean` for TidalPod Guest State on (`true`) or off (`false`)


/pools/{poolId}/pods/{podId}/guest

Usage and SDK Samples

curl -X POST "https://api.tidalscale.com/v1/pools/{poolId}/pods/{podId}/guest"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PodsApi;

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

public class PodsApiExample {

    public static void main(String[] args) {
        
        PodsApi apiInstance = new PodsApi();
        String poolId = poolId_example; // String | The ID of the desired TidalPool containing this TidalPod
        String podId = podId_example; // String | The ID of the desired TidalPod
        PodGuest podGuest = ; // PodGuest | Set status `boolean` for TidalPod Guest State on (`true`) or off (`false`)
        try {
            inline_response_201_1 result = apiInstance.bootPodGuest(poolId, podId, podGuest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PodsApi#bootPodGuest");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.PodsApi;

public class PodsApiExample {

    public static void main(String[] args) {
        PodsApi apiInstance = new PodsApi();
        String poolId = poolId_example; // String | The ID of the desired TidalPool containing this TidalPod
        String podId = podId_example; // String | The ID of the desired TidalPod
        PodGuest podGuest = ; // PodGuest | Set status `boolean` for TidalPod Guest State on (`true`) or off (`false`)
        try {
            inline_response_201_1 result = apiInstance.bootPodGuest(poolId, podId, podGuest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PodsApi#bootPodGuest");
            e.printStackTrace();
        }
    }
}
String *poolId = poolId_example; // The ID of the desired TidalPool containing this TidalPod
String *podId = podId_example; // The ID of the desired TidalPod
PodGuest *podGuest = ; // Set status `boolean` for TidalPod Guest State on (`true`) or off (`false`)

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

// Boot or Shutdown TidalPod Guest
[apiInstance bootPodGuestWith:poolId
    podId:podId
    podGuest:podGuest
              completionHandler: ^(inline_response_201_1 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WaveRunnerApi = require('wave_runner_api');

var api = new WaveRunnerApi.PodsApi()

var poolId = poolId_example; // {String} The ID of the desired TidalPool containing this TidalPod

var podId = podId_example; // {String} The ID of the desired TidalPod

var podGuest = ; // {PodGuest} Set status `boolean` for TidalPod Guest State on (`true`) or off (`false`)


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

namespace Example
{
    public class bootPodGuestExample
    {
        public void main()
        {
            
            var apiInstance = new PodsApi();
            var poolId = poolId_example;  // String | The ID of the desired TidalPool containing this TidalPod
            var podId = podId_example;  // String | The ID of the desired TidalPod
            var podGuest = new PodGuest(); // PodGuest | Set status `boolean` for TidalPod Guest State on (`true`) or off (`false`)

            try
            {
                // Boot or Shutdown TidalPod Guest
                inline_response_201_1 result = apiInstance.bootPodGuest(poolId, podId, podGuest);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PodsApi.bootPodGuest: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\PodsApi();
$poolId = poolId_example; // String | The ID of the desired TidalPool containing this TidalPod
$podId = podId_example; // String | The ID of the desired TidalPod
$podGuest = ; // PodGuest | Set status `boolean` for TidalPod Guest State on (`true`) or off (`false`)

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

my $api_instance = WWW::SwaggerClient::PodsApi->new();
my $poolId = poolId_example; # String | The ID of the desired TidalPool containing this TidalPod
my $podId = podId_example; # String | The ID of the desired TidalPod
my $podGuest = WWW::SwaggerClient::Object::PodGuest->new(); # PodGuest | Set status `boolean` for TidalPod Guest State on (`true`) or off (`false`)

eval { 
    my $result = $api_instance->bootPodGuest(poolId => $poolId, podId => $podId, podGuest => $podGuest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PodsApi->bootPodGuest: $@\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.PodsApi()
poolId = poolId_example # String | The ID of the desired TidalPool containing this TidalPod
podId = podId_example # String | The ID of the desired TidalPod
podGuest =  # PodGuest | Set status `boolean` for TidalPod Guest State on (`true`) or off (`false`)

try: 
    # Boot or Shutdown TidalPod Guest
    api_response = api_instance.boot_pod_guest(poolId, podId, podGuest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PodsApi->bootPodGuest: %s\n" % e)

Parameters

Path parameters
Name Description
poolId*
String
The ID of the desired TidalPool containing this TidalPod
Required
podId*
String
The ID of the desired TidalPod
Required
Body parameters
Name Description
podGuest *

Responses

Status: 201 - Guest state change task

Status: 500 - Internal Server Error


deletePod

Delete a TidalPod from the TidalPool

The optional fields `keepConfig` and `keepFiles` are a convenience feature, equivalent to setting the TidalPod's `podOptions`, `keepConfigOnDelete` and/or `keepFilesOnDelete` to `false` at time of deletion


/pools/{poolId}/pods/{podId}

Usage and SDK Samples

curl -X DELETE "https://api.tidalscale.com/v1/pools/{poolId}/pods/{podId}?keepConfig=&keepFiles="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PodsApi;

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

public class PodsApiExample {

    public static void main(String[] args) {
        
        PodsApi apiInstance = new PodsApi();
        String poolId = poolId_example; // String | The ID of the desired TidalPool containing this TidalPod
        String podId = podId_example; // String | The ID of the desired TidalPod containing this Node
        Boolean keepConfig = true; // Boolean | Keep config after TidalPod is deleted
        Boolean keepFiles = true; // Boolean | Keep files after TidalPod is deleted
        try {
            apiInstance.deletePod(poolId, podId, keepConfig, keepFiles);
        } catch (ApiException e) {
            System.err.println("Exception when calling PodsApi#deletePod");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.PodsApi;

public class PodsApiExample {

    public static void main(String[] args) {
        PodsApi apiInstance = new PodsApi();
        String poolId = poolId_example; // String | The ID of the desired TidalPool containing this TidalPod
        String podId = podId_example; // String | The ID of the desired TidalPod containing this Node
        Boolean keepConfig = true; // Boolean | Keep config after TidalPod is deleted
        Boolean keepFiles = true; // Boolean | Keep files after TidalPod is deleted
        try {
            apiInstance.deletePod(poolId, podId, keepConfig, keepFiles);
        } catch (ApiException e) {
            System.err.println("Exception when calling PodsApi#deletePod");
            e.printStackTrace();
        }
    }
}
String *poolId = poolId_example; // The ID of the desired TidalPool containing this TidalPod
String *podId = podId_example; // The ID of the desired TidalPod containing this Node
Boolean *keepConfig = true; // Keep config after TidalPod is deleted (optional)
Boolean *keepFiles = true; // Keep files after TidalPod is deleted (optional)

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

// Delete a TidalPod from the TidalPool
[apiInstance deletePodWith:poolId
    podId:podId
    keepConfig:keepConfig
    keepFiles:keepFiles
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WaveRunnerApi = require('wave_runner_api');

var api = new WaveRunnerApi.PodsApi()

var poolId = poolId_example; // {String} The ID of the desired TidalPool containing this TidalPod

var podId = podId_example; // {String} The ID of the desired TidalPod containing this Node

var opts = { 
  'keepConfig': true, // {Boolean} Keep config after TidalPod is deleted
  'keepFiles': true // {Boolean} Keep files after TidalPod is deleted
};

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

namespace Example
{
    public class deletePodExample
    {
        public void main()
        {
            
            var apiInstance = new PodsApi();
            var poolId = poolId_example;  // String | The ID of the desired TidalPool containing this TidalPod
            var podId = podId_example;  // String | The ID of the desired TidalPod containing this Node
            var keepConfig = true;  // Boolean | Keep config after TidalPod is deleted (optional) 
            var keepFiles = true;  // Boolean | Keep files after TidalPod is deleted (optional) 

            try
            {
                // Delete a TidalPod from the TidalPool
                apiInstance.deletePod(poolId, podId, keepConfig, keepFiles);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PodsApi.deletePod: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\PodsApi();
$poolId = poolId_example; // String | The ID of the desired TidalPool containing this TidalPod
$podId = podId_example; // String | The ID of the desired TidalPod containing this Node
$keepConfig = true; // Boolean | Keep config after TidalPod is deleted
$keepFiles = true; // Boolean | Keep files after TidalPod is deleted

try {
    $api_instance->deletePod($poolId, $podId, $keepConfig, $keepFiles);
} catch (Exception $e) {
    echo 'Exception when calling PodsApi->deletePod: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PodsApi;

my $api_instance = WWW::SwaggerClient::PodsApi->new();
my $poolId = poolId_example; # String | The ID of the desired TidalPool containing this TidalPod
my $podId = podId_example; # String | The ID of the desired TidalPod containing this Node
my $keepConfig = true; # Boolean | Keep config after TidalPod is deleted
my $keepFiles = true; # Boolean | Keep files after TidalPod is deleted

eval { 
    $api_instance->deletePod(poolId => $poolId, podId => $podId, keepConfig => $keepConfig, keepFiles => $keepFiles);
};
if ($@) {
    warn "Exception when calling PodsApi->deletePod: $@\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.PodsApi()
poolId = poolId_example # String | The ID of the desired TidalPool containing this TidalPod
podId = podId_example # String | The ID of the desired TidalPod containing this Node
keepConfig = true # Boolean | Keep config after TidalPod is deleted (optional)
keepFiles = true # Boolean | Keep files after TidalPod is deleted (optional)

try: 
    # Delete a TidalPod from the TidalPool
    api_instance.delete_pod(poolId, podId, keepConfig=keepConfig, keepFiles=keepFiles)
except ApiException as e:
    print("Exception when calling PodsApi->deletePod: %s\n" % e)

Parameters

Path parameters
Name Description
poolId*
String
The ID of the desired TidalPool containing this TidalPod
Required
podId*
String
The ID of the desired TidalPod containing this Node
Required
Query parameters
Name Description
keepConfig
Boolean
Keep config after TidalPod is deleted
keepFiles
Boolean
Keep files after TidalPod is deleted

Responses

Status: 200 - OK

Status: 500 - Internal Server Error


getGuestConsoleWebSocket

WebSocket to connect to guest shell

streams the websocket to a new guest shell connection.


/pools/{poolId}/pods/{podId}/ws/guestconsole

Usage and SDK Samples

curl -X GET "https://api.tidalscale.com/v1/pools/{poolId}/pods/{podId}/ws/guestconsole"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PodsApi;

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

public class PodsApiExample {

    public static void main(String[] args) {
        
        PodsApi apiInstance = new PodsApi();
        String poolId = poolId_example; // String | The ID of the desired TidalPool containing this TidalPod
        String podId = podId_example; // String | The ID of the desired TidalPod connect to guest console
        try {
            apiInstance.getGuestConsoleWebSocket(poolId, podId);
        } catch (ApiException e) {
            System.err.println("Exception when calling PodsApi#getGuestConsoleWebSocket");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.PodsApi;

public class PodsApiExample {

    public static void main(String[] args) {
        PodsApi apiInstance = new PodsApi();
        String poolId = poolId_example; // String | The ID of the desired TidalPool containing this TidalPod
        String podId = podId_example; // String | The ID of the desired TidalPod connect to guest console
        try {
            apiInstance.getGuestConsoleWebSocket(poolId, podId);
        } catch (ApiException e) {
            System.err.println("Exception when calling PodsApi#getGuestConsoleWebSocket");
            e.printStackTrace();
        }
    }
}
String *poolId = poolId_example; // The ID of the desired TidalPool containing this TidalPod
String *podId = podId_example; // The ID of the desired TidalPod connect to guest console

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

// WebSocket to connect to guest shell
[apiInstance getGuestConsoleWebSocketWith:poolId
    podId:podId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WaveRunnerApi = require('wave_runner_api');

var api = new WaveRunnerApi.PodsApi()

var poolId = poolId_example; // {String} The ID of the desired TidalPool containing this TidalPod

var podId = podId_example; // {String} The ID of the desired TidalPod connect to guest console


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

namespace Example
{
    public class getGuestConsoleWebSocketExample
    {
        public void main()
        {
            
            var apiInstance = new PodsApi();
            var poolId = poolId_example;  // String | The ID of the desired TidalPool containing this TidalPod
            var podId = podId_example;  // String | The ID of the desired TidalPod connect to guest console

            try
            {
                // WebSocket to connect to guest shell
                apiInstance.getGuestConsoleWebSocket(poolId, podId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PodsApi.getGuestConsoleWebSocket: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\PodsApi();
$poolId = poolId_example; // String | The ID of the desired TidalPool containing this TidalPod
$podId = podId_example; // String | The ID of the desired TidalPod connect to guest console

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

my $api_instance = WWW::SwaggerClient::PodsApi->new();
my $poolId = poolId_example; # String | The ID of the desired TidalPool containing this TidalPod
my $podId = podId_example; # String | The ID of the desired TidalPod connect to guest console

eval { 
    $api_instance->getGuestConsoleWebSocket(poolId => $poolId, podId => $podId);
};
if ($@) {
    warn "Exception when calling PodsApi->getGuestConsoleWebSocket: $@\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.PodsApi()
poolId = poolId_example # String | The ID of the desired TidalPool containing this TidalPod
podId = podId_example # String | The ID of the desired TidalPod connect to guest console

try: 
    # WebSocket to connect to guest shell
    api_instance.get_guest_console_web_socket(poolId, podId)
except ApiException as e:
    print("Exception when calling PodsApi->getGuestConsoleWebSocket: %s\n" % e)

Parameters

Path parameters
Name Description
poolId*
String
The ID of the desired TidalPool containing this TidalPod
Required
podId*
String
The ID of the desired TidalPod connect to guest console
Required

Responses

Status: 200 - OK

Status: 404 - No guest console found

Status: 500 - Internal Server Error


getGuestShellWebSocket

WebSocket to connect to guest shell

Streams the websocket to a new guest shell connection. The username may be specified with the optional "user@" prefix to guestshell


/pools/{poolId}/pods/{podId}/ws/<user@>guestshell

Usage and SDK Samples

curl -X GET "https://api.tidalscale.com/v1/pools/{poolId}/pods/{podId}/ws/<user@>guestshell"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PodsApi;

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

public class PodsApiExample {

    public static void main(String[] args) {
        
        PodsApi apiInstance = new PodsApi();
        String poolId = poolId_example; // String | The ID of the desired TidalPool containing this TidalPod
        String podId = podId_example; // String | The ID of the desired TidalPod to connect to guest shell
        try {
            apiInstance.getGuestShellWebSocket(poolId, podId);
        } catch (ApiException e) {
            System.err.println("Exception when calling PodsApi#getGuestShellWebSocket");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.PodsApi;

public class PodsApiExample {

    public static void main(String[] args) {
        PodsApi apiInstance = new PodsApi();
        String poolId = poolId_example; // String | The ID of the desired TidalPool containing this TidalPod
        String podId = podId_example; // String | The ID of the desired TidalPod to connect to guest shell
        try {
            apiInstance.getGuestShellWebSocket(poolId, podId);
        } catch (ApiException e) {
            System.err.println("Exception when calling PodsApi#getGuestShellWebSocket");
            e.printStackTrace();
        }
    }
}
String *poolId = poolId_example; // The ID of the desired TidalPool containing this TidalPod
String *podId = podId_example; // The ID of the desired TidalPod to connect to guest shell

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

// WebSocket to connect to guest shell
[apiInstance getGuestShellWebSocketWith:poolId
    podId:podId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WaveRunnerApi = require('wave_runner_api');

var api = new WaveRunnerApi.PodsApi()

var poolId = poolId_example; // {String} The ID of the desired TidalPool containing this TidalPod

var podId = podId_example; // {String} The ID of the desired TidalPod to connect to guest shell


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

namespace Example
{
    public class getGuestShellWebSocketExample
    {
        public void main()
        {
            
            var apiInstance = new PodsApi();
            var poolId = poolId_example;  // String | The ID of the desired TidalPool containing this TidalPod
            var podId = podId_example;  // String | The ID of the desired TidalPod to connect to guest shell

            try
            {
                // WebSocket to connect to guest shell
                apiInstance.getGuestShellWebSocket(poolId, podId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PodsApi.getGuestShellWebSocket: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\PodsApi();
$poolId = poolId_example; // String | The ID of the desired TidalPool containing this TidalPod
$podId = podId_example; // String | The ID of the desired TidalPod to connect to guest shell

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

my $api_instance = WWW::SwaggerClient::PodsApi->new();
my $poolId = poolId_example; # String | The ID of the desired TidalPool containing this TidalPod
my $podId = podId_example; # String | The ID of the desired TidalPod to connect to guest shell

eval { 
    $api_instance->getGuestShellWebSocket(poolId => $poolId, podId => $podId);
};
if ($@) {
    warn "Exception when calling PodsApi->getGuestShellWebSocket: $@\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.PodsApi()
poolId = poolId_example # String | The ID of the desired TidalPool containing this TidalPod
podId = podId_example # String | The ID of the desired TidalPod to connect to guest shell

try: 
    # WebSocket to connect to guest shell
    api_instance.get_guest_shell_web_socket(poolId, podId)
except ApiException as e:
    print("Exception when calling PodsApi->getGuestShellWebSocket: %s\n" % e)

Parameters

Path parameters
Name Description
poolId*
String
The ID of the desired TidalPool containing this TidalPod
Required
podId*
String
The ID of the desired TidalPod to connect to guest shell
Required

Responses

Status: 200 - OK

Status: 404 - No guest shell found

Status: 500 - Internal Server Error


getNodeConsWsHandler

WebSocket to connect to node console

streams the websocket to a node console.


/pools/{poolId}/pods/{podId}/nodes/{nodeId}/ws/console

Usage and SDK Samples

curl -X GET "https://api.tidalscale.com/v1/pools/{poolId}/pods/{podId}/nodes/{nodeId}/ws/console"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PodsApi;

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

public class PodsApiExample {

    public static void main(String[] args) {
        
        PodsApi apiInstance = new PodsApi();
        String poolId = poolId_example; // String | The ID of the desired TidalPool containing this TidalPod
        String podId = podId_example; // String | The ID of the desired TidalPod containing this Node
        String nodeId = nodeId_example; // String | The ID of the desired Node
        try {
            apiInstance.getNodeConsWsHandler(poolId, podId, nodeId);
        } catch (ApiException e) {
            System.err.println("Exception when calling PodsApi#getNodeConsWsHandler");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.PodsApi;

public class PodsApiExample {

    public static void main(String[] args) {
        PodsApi apiInstance = new PodsApi();
        String poolId = poolId_example; // String | The ID of the desired TidalPool containing this TidalPod
        String podId = podId_example; // String | The ID of the desired TidalPod containing this Node
        String nodeId = nodeId_example; // String | The ID of the desired Node
        try {
            apiInstance.getNodeConsWsHandler(poolId, podId, nodeId);
        } catch (ApiException e) {
            System.err.println("Exception when calling PodsApi#getNodeConsWsHandler");
            e.printStackTrace();
        }
    }
}
String *poolId = poolId_example; // The ID of the desired TidalPool containing this TidalPod
String *podId = podId_example; // The ID of the desired TidalPod containing this Node
String *nodeId = nodeId_example; // The ID of the desired Node

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

// WebSocket to connect to node console
[apiInstance getNodeConsWsHandlerWith:poolId
    podId:podId
    nodeId:nodeId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WaveRunnerApi = require('wave_runner_api');

var api = new WaveRunnerApi.PodsApi()

var poolId = poolId_example; // {String} The ID of the desired TidalPool containing this TidalPod

var podId = podId_example; // {String} The ID of the desired TidalPod containing this Node

var nodeId = nodeId_example; // {String} The ID of the desired Node


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

namespace Example
{
    public class getNodeConsWsHandlerExample
    {
        public void main()
        {
            
            var apiInstance = new PodsApi();
            var poolId = poolId_example;  // String | The ID of the desired TidalPool containing this TidalPod
            var podId = podId_example;  // String | The ID of the desired TidalPod containing this Node
            var nodeId = nodeId_example;  // String | The ID of the desired Node

            try
            {
                // WebSocket to connect to node console
                apiInstance.getNodeConsWsHandler(poolId, podId, nodeId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PodsApi.getNodeConsWsHandler: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\PodsApi();
$poolId = poolId_example; // String | The ID of the desired TidalPool containing this TidalPod
$podId = podId_example; // String | The ID of the desired TidalPod containing this Node
$nodeId = nodeId_example; // String | The ID of the desired Node

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

my $api_instance = WWW::SwaggerClient::PodsApi->new();
my $poolId = poolId_example; # String | The ID of the desired TidalPool containing this TidalPod
my $podId = podId_example; # String | The ID of the desired TidalPod containing this Node
my $nodeId = nodeId_example; # String | The ID of the desired Node

eval { 
    $api_instance->getNodeConsWsHandler(poolId => $poolId, podId => $podId, nodeId => $nodeId);
};
if ($@) {
    warn "Exception when calling PodsApi->getNodeConsWsHandler: $@\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.PodsApi()
poolId = poolId_example # String | The ID of the desired TidalPool containing this TidalPod
podId = podId_example # String | The ID of the desired TidalPod containing this Node
nodeId = nodeId_example # String | The ID of the desired Node

try: 
    # WebSocket to connect to node console
    api_instance.get_node_cons_ws_handler(poolId, podId, nodeId)
except ApiException as e:
    print("Exception when calling PodsApi->getNodeConsWsHandler: %s\n" % e)

Parameters

Path parameters
Name Description
poolId*
String
The ID of the desired TidalPool containing this TidalPod
Required
podId*
String
The ID of the desired TidalPod containing this Node
Required
nodeId*
String
The ID of the desired Node
Required

Responses

Status: 200 - OK

Status: 404 - Console not found

Status: 500 - Internal Server Error


getNodeShellWsHandler

WebSocket to connect to node shell

streams the websocket to a new node shell connection.


/pools/{poolId}/pods/{podId}/nodes/{nodeId}/ws/shell

Usage and SDK Samples

curl -X GET "https://api.tidalscale.com/v1/pools/{poolId}/pods/{podId}/nodes/{nodeId}/ws/shell"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PodsApi;

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

public class PodsApiExample {

    public static void main(String[] args) {
        
        PodsApi apiInstance = new PodsApi();
        String poolId = poolId_example; // String | The ID of the desired TidalPool containing this TidalPod
        String podId = podId_example; // String | The ID of the desired TidalPod containing this Node
        String nodeId = nodeId_example; // String | The ID of the desired Node
        try {
            apiInstance.getNodeShellWsHandler(poolId, podId, nodeId);
        } catch (ApiException e) {
            System.err.println("Exception when calling PodsApi#getNodeShellWsHandler");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.PodsApi;

public class PodsApiExample {

    public static void main(String[] args) {
        PodsApi apiInstance = new PodsApi();
        String poolId = poolId_example; // String | The ID of the desired TidalPool containing this TidalPod
        String podId = podId_example; // String | The ID of the desired TidalPod containing this Node
        String nodeId = nodeId_example; // String | The ID of the desired Node
        try {
            apiInstance.getNodeShellWsHandler(poolId, podId, nodeId);
        } catch (ApiException e) {
            System.err.println("Exception when calling PodsApi#getNodeShellWsHandler");
            e.printStackTrace();
        }
    }
}
String *poolId = poolId_example; // The ID of the desired TidalPool containing this TidalPod
String *podId = podId_example; // The ID of the desired TidalPod containing this Node
String *nodeId = nodeId_example; // The ID of the desired Node

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

// WebSocket to connect to node shell
[apiInstance getNodeShellWsHandlerWith:poolId
    podId:podId
    nodeId:nodeId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WaveRunnerApi = require('wave_runner_api');

var api = new WaveRunnerApi.PodsApi()

var poolId = poolId_example; // {String} The ID of the desired TidalPool containing this TidalPod

var podId = podId_example; // {String} The ID of the desired TidalPod containing this Node

var nodeId = nodeId_example; // {String} The ID of the desired Node


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

namespace Example
{
    public class getNodeShellWsHandlerExample
    {
        public void main()
        {
            
            var apiInstance = new PodsApi();
            var poolId = poolId_example;  // String | The ID of the desired TidalPool containing this TidalPod
            var podId = podId_example;  // String | The ID of the desired TidalPod containing this Node
            var nodeId = nodeId_example;  // String | The ID of the desired Node

            try
            {
                // WebSocket to connect to node shell
                apiInstance.getNodeShellWsHandler(poolId, podId, nodeId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PodsApi.getNodeShellWsHandler: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\PodsApi();
$poolId = poolId_example; // String | The ID of the desired TidalPool containing this TidalPod
$podId = podId_example; // String | The ID of the desired TidalPod containing this Node
$nodeId = nodeId_example; // String | The ID of the desired Node

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

my $api_instance = WWW::SwaggerClient::PodsApi->new();
my $poolId = poolId_example; # String | The ID of the desired TidalPool containing this TidalPod
my $podId = podId_example; # String | The ID of the desired TidalPod containing this Node
my $nodeId = nodeId_example; # String | The ID of the desired Node

eval { 
    $api_instance->getNodeShellWsHandler(poolId => $poolId, podId => $podId, nodeId => $nodeId);
};
if ($@) {
    warn "Exception when calling PodsApi->getNodeShellWsHandler: $@\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.PodsApi()
poolId = poolId_example # String | The ID of the desired TidalPool containing this TidalPod
podId = podId_example # String | The ID of the desired TidalPod containing this Node
nodeId = nodeId_example # String | The ID of the desired Node

try: 
    # WebSocket to connect to node shell
    api_instance.get_node_shell_ws_handler(poolId, podId, nodeId)
except ApiException as e:
    print("Exception when calling PodsApi->getNodeShellWsHandler: %s\n" % e)

Parameters

Path parameters
Name Description
poolId*
String
The ID of the desired TidalPool containing this TidalPod
Required
podId*
String
The ID of the desired TidalPod containing this Node
Required
nodeId*
String
The ID of the desired Node
Required

Responses

Status: 200 - OK

Status: 404 - Shell not found

Status: 500 - Internal Server Error


getPod

Return a single TidalPod


/pools/{poolId}/pods/{podId}

Usage and SDK Samples

curl -X GET "https://api.tidalscale.com/v1/pools/{poolId}/pods/{podId}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PodsApi;

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

public class PodsApiExample {

    public static void main(String[] args) {
        
        PodsApi apiInstance = new PodsApi();
        String poolId = poolId_example; // String | The ID of the desired TidalPool containing this TidalPod
        String podId = podId_example; // String | The ID of the TidalPod to return
        try {
            inline_response_200_3 result = apiInstance.getPod(poolId, podId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PodsApi#getPod");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.PodsApi;

public class PodsApiExample {

    public static void main(String[] args) {
        PodsApi apiInstance = new PodsApi();
        String poolId = poolId_example; // String | The ID of the desired TidalPool containing this TidalPod
        String podId = podId_example; // String | The ID of the TidalPod to return
        try {
            inline_response_200_3 result = apiInstance.getPod(poolId, podId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PodsApi#getPod");
            e.printStackTrace();
        }
    }
}
String *poolId = poolId_example; // The ID of the desired TidalPool containing this TidalPod
String *podId = podId_example; // The ID of the TidalPod to return

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

// Return a single TidalPod
[apiInstance getPodWith:poolId
    podId:podId
              completionHandler: ^(inline_response_200_3 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WaveRunnerApi = require('wave_runner_api');

var api = new WaveRunnerApi.PodsApi()

var poolId = poolId_example; // {String} The ID of the desired TidalPool containing this TidalPod

var podId = podId_example; // {String} The ID of the TidalPod to return


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

namespace Example
{
    public class getPodExample
    {
        public void main()
        {
            
            var apiInstance = new PodsApi();
            var poolId = poolId_example;  // String | The ID of the desired TidalPool containing this TidalPod
            var podId = podId_example;  // String | The ID of the TidalPod to return

            try
            {
                // Return a single TidalPod
                inline_response_200_3 result = apiInstance.getPod(poolId, podId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PodsApi.getPod: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\PodsApi();
$poolId = poolId_example; // String | The ID of the desired TidalPool containing this TidalPod
$podId = podId_example; // String | The ID of the TidalPod to return

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

my $api_instance = WWW::SwaggerClient::PodsApi->new();
my $poolId = poolId_example; # String | The ID of the desired TidalPool containing this TidalPod
my $podId = podId_example; # String | The ID of the TidalPod to return

eval { 
    my $result = $api_instance->getPod(poolId => $poolId, podId => $podId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PodsApi->getPod: $@\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.PodsApi()
poolId = poolId_example # String | The ID of the desired TidalPool containing this TidalPod
podId = podId_example # String | The ID of the TidalPod to return

try: 
    # Return a single TidalPod
    api_response = api_instance.get_pod(poolId, podId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PodsApi->getPod: %s\n" % e)

Parameters

Path parameters
Name Description
poolId*
String
The ID of the desired TidalPool containing this TidalPod
Required
podId*
String
The ID of the TidalPod to return
Required

Responses

Status: 200 - OK

Status: 404 - No TidalPod found with that ID

Status: 500 - Internal Server Error


getPodConsolesWebSocket

WebSocket to connect to consoles of the nodes in the TidalPod

Streams a read-only websocket to the TidalPod Node consoles to identify boot issues.


/pools/{poolId}/pods/{podId}/ws/consoles

Usage and SDK Samples

curl -X GET "https://api.tidalscale.com/v1/pools/{poolId}/pods/{podId}/ws/consoles"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PodsApi;

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

public class PodsApiExample {

    public static void main(String[] args) {
        
        PodsApi apiInstance = new PodsApi();
        String poolId = poolId_example; // String | The ID of the desired TidalPool containing this TidalPod
        String podId = podId_example; // String | The ID of the desired TidalPod connect to the consoles
        try {
            apiInstance.getPodConsolesWebSocket(poolId, podId);
        } catch (ApiException e) {
            System.err.println("Exception when calling PodsApi#getPodConsolesWebSocket");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.PodsApi;

public class PodsApiExample {

    public static void main(String[] args) {
        PodsApi apiInstance = new PodsApi();
        String poolId = poolId_example; // String | The ID of the desired TidalPool containing this TidalPod
        String podId = podId_example; // String | The ID of the desired TidalPod connect to the consoles
        try {
            apiInstance.getPodConsolesWebSocket(poolId, podId);
        } catch (ApiException e) {
            System.err.println("Exception when calling PodsApi#getPodConsolesWebSocket");
            e.printStackTrace();
        }
    }
}
String *poolId = poolId_example; // The ID of the desired TidalPool containing this TidalPod
String *podId = podId_example; // The ID of the desired TidalPod connect to the consoles

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

// WebSocket to connect to consoles of the nodes in the TidalPod
[apiInstance getPodConsolesWebSocketWith:poolId
    podId:podId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WaveRunnerApi = require('wave_runner_api');

var api = new WaveRunnerApi.PodsApi()

var poolId = poolId_example; // {String} The ID of the desired TidalPool containing this TidalPod

var podId = podId_example; // {String} The ID of the desired TidalPod connect to the consoles


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

namespace Example
{
    public class getPodConsolesWebSocketExample
    {
        public void main()
        {
            
            var apiInstance = new PodsApi();
            var poolId = poolId_example;  // String | The ID of the desired TidalPool containing this TidalPod
            var podId = podId_example;  // String | The ID of the desired TidalPod connect to the consoles

            try
            {
                // WebSocket to connect to consoles of the nodes in the TidalPod
                apiInstance.getPodConsolesWebSocket(poolId, podId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PodsApi.getPodConsolesWebSocket: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\PodsApi();
$poolId = poolId_example; // String | The ID of the desired TidalPool containing this TidalPod
$podId = podId_example; // String | The ID of the desired TidalPod connect to the consoles

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

my $api_instance = WWW::SwaggerClient::PodsApi->new();
my $poolId = poolId_example; # String | The ID of the desired TidalPool containing this TidalPod
my $podId = podId_example; # String | The ID of the desired TidalPod connect to the consoles

eval { 
    $api_instance->getPodConsolesWebSocket(poolId => $poolId, podId => $podId);
};
if ($@) {
    warn "Exception when calling PodsApi->getPodConsolesWebSocket: $@\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.PodsApi()
poolId = poolId_example # String | The ID of the desired TidalPool containing this TidalPod
podId = podId_example # String | The ID of the desired TidalPod connect to the consoles

try: 
    # WebSocket to connect to consoles of the nodes in the TidalPod
    api_instance.get_pod_consoles_web_socket(poolId, podId)
except ApiException as e:
    print("Exception when calling PodsApi->getPodConsolesWebSocket: %s\n" % e)

Parameters

Path parameters
Name Description
poolId*
String
The ID of the desired TidalPool containing this TidalPod
Required
podId*
String
The ID of the desired TidalPod connect to the consoles
Required

Responses

Status: 200 - OK

Status: 404 - No console found

Status: 500 - Internal Server Error


getPodQuickstats

Return TidalPod stats for the WaveRunner admin UI

A convenience method to get the stats for a TidalPod, which represents a roll up of all stats for a Node


/pools/{poolId}/pods/{podId}/quickstats

Usage and SDK Samples

curl -X GET "https://api.tidalscale.com/v1/pools/{poolId}/pods/{podId}/quickstats"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PodsApi;

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

public class PodsApiExample {

    public static void main(String[] args) {
        
        PodsApi apiInstance = new PodsApi();
        String poolId = poolId_example; // String | The ID of the desired TidalPool containing this TidalPod
        String podId = podId_example; // String | The ID of the desired TidalPod to return stats about
        try {
            poolspoolIdpods_podQuickstats result = apiInstance.getPodQuickstats(poolId, podId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PodsApi#getPodQuickstats");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.PodsApi;

public class PodsApiExample {

    public static void main(String[] args) {
        PodsApi apiInstance = new PodsApi();
        String poolId = poolId_example; // String | The ID of the desired TidalPool containing this TidalPod
        String podId = podId_example; // String | The ID of the desired TidalPod to return stats about
        try {
            poolspoolIdpods_podQuickstats result = apiInstance.getPodQuickstats(poolId, podId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PodsApi#getPodQuickstats");
            e.printStackTrace();
        }
    }
}
String *poolId = poolId_example; // The ID of the desired TidalPool containing this TidalPod
String *podId = podId_example; // The ID of the desired TidalPod to return stats about

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

// Return TidalPod stats for the WaveRunner admin UI
[apiInstance getPodQuickstatsWith:poolId
    podId:podId
              completionHandler: ^(poolspoolIdpods_podQuickstats output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WaveRunnerApi = require('wave_runner_api');

var api = new WaveRunnerApi.PodsApi()

var poolId = poolId_example; // {String} The ID of the desired TidalPool containing this TidalPod

var podId = podId_example; // {String} The ID of the desired TidalPod to return stats about


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

namespace Example
{
    public class getPodQuickstatsExample
    {
        public void main()
        {
            
            var apiInstance = new PodsApi();
            var poolId = poolId_example;  // String | The ID of the desired TidalPool containing this TidalPod
            var podId = podId_example;  // String | The ID of the desired TidalPod to return stats about

            try
            {
                // Return TidalPod stats for the WaveRunner admin UI
                poolspoolIdpods_podQuickstats result = apiInstance.getPodQuickstats(poolId, podId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PodsApi.getPodQuickstats: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\PodsApi();
$poolId = poolId_example; // String | The ID of the desired TidalPool containing this TidalPod
$podId = podId_example; // String | The ID of the desired TidalPod to return stats about

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

my $api_instance = WWW::SwaggerClient::PodsApi->new();
my $poolId = poolId_example; # String | The ID of the desired TidalPool containing this TidalPod
my $podId = podId_example; # String | The ID of the desired TidalPod to return stats about

eval { 
    my $result = $api_instance->getPodQuickstats(poolId => $poolId, podId => $podId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PodsApi->getPodQuickstats: $@\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.PodsApi()
poolId = poolId_example # String | The ID of the desired TidalPool containing this TidalPod
podId = podId_example # String | The ID of the desired TidalPod to return stats about

try: 
    # Return TidalPod stats for the WaveRunner admin UI
    api_response = api_instance.get_pod_quickstats(poolId, podId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PodsApi->getPodQuickstats: %s\n" % e)

Parameters

Path parameters
Name Description
poolId*
String
The ID of the desired TidalPool containing this TidalPod
Required
podId*
String
The ID of the desired TidalPod to return stats about
Required

Responses

Status: 200 - OK

Status: 404 - No Quickstats found for that TidalPod

Status: 500 - Internal Server Error


getPodQuickstatsWebSocket

WebSocket stream the TidalPod's and its Nodes quickstats

Returns records similar to the TidalPods quickstats REST call. If the stats is for a set of Nodes, then nodeStats will contain a list of stats for those Nodes.


/pools/{poolId}/pods/{podId}/ws/quickstats

Usage and SDK Samples

curl -X GET "https://api.tidalscale.com/v1/pools/{poolId}/pods/{podId}/ws/quickstats"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PodsApi;

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

public class PodsApiExample {

    public static void main(String[] args) {
        
        PodsApi apiInstance = new PodsApi();
        String poolId = poolId_example; // String | The ID of the desired TidalPool containing this TidalPod
        String podId = podId_example; // String | The ID of the desired TidalPod to return stats about
        try {
            inline_response_200_4 result = apiInstance.getPodQuickstatsWebSocket(poolId, podId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PodsApi#getPodQuickstatsWebSocket");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.PodsApi;

public class PodsApiExample {

    public static void main(String[] args) {
        PodsApi apiInstance = new PodsApi();
        String poolId = poolId_example; // String | The ID of the desired TidalPool containing this TidalPod
        String podId = podId_example; // String | The ID of the desired TidalPod to return stats about
        try {
            inline_response_200_4 result = apiInstance.getPodQuickstatsWebSocket(poolId, podId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PodsApi#getPodQuickstatsWebSocket");
            e.printStackTrace();
        }
    }
}
String *poolId = poolId_example; // The ID of the desired TidalPool containing this TidalPod
String *podId = podId_example; // The ID of the desired TidalPod to return stats about

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

// WebSocket stream the TidalPod's and its Nodes quickstats
[apiInstance getPodQuickstatsWebSocketWith:poolId
    podId:podId
              completionHandler: ^(inline_response_200_4 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WaveRunnerApi = require('wave_runner_api');

var api = new WaveRunnerApi.PodsApi()

var poolId = poolId_example; // {String} The ID of the desired TidalPool containing this TidalPod

var podId = podId_example; // {String} The ID of the desired TidalPod to return stats about


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

namespace Example
{
    public class getPodQuickstatsWebSocketExample
    {
        public void main()
        {
            
            var apiInstance = new PodsApi();
            var poolId = poolId_example;  // String | The ID of the desired TidalPool containing this TidalPod
            var podId = podId_example;  // String | The ID of the desired TidalPod to return stats about

            try
            {
                // WebSocket stream the TidalPod's and its Nodes quickstats
                inline_response_200_4 result = apiInstance.getPodQuickstatsWebSocket(poolId, podId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PodsApi.getPodQuickstatsWebSocket: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\PodsApi();
$poolId = poolId_example; // String | The ID of the desired TidalPool containing this TidalPod
$podId = podId_example; // String | The ID of the desired TidalPod to return stats about

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

my $api_instance = WWW::SwaggerClient::PodsApi->new();
my $poolId = poolId_example; # String | The ID of the desired TidalPool containing this TidalPod
my $podId = podId_example; # String | The ID of the desired TidalPod to return stats about

eval { 
    my $result = $api_instance->getPodQuickstatsWebSocket(poolId => $poolId, podId => $podId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PodsApi->getPodQuickstatsWebSocket: $@\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.PodsApi()
poolId = poolId_example # String | The ID of the desired TidalPool containing this TidalPod
podId = podId_example # String | The ID of the desired TidalPod to return stats about

try: 
    # WebSocket stream the TidalPod's and its Nodes quickstats
    api_response = api_instance.get_pod_quickstats_web_socket(poolId, podId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PodsApi->getPodQuickstatsWebSocket: %s\n" % e)

Parameters

Path parameters
Name Description
poolId*
String
The ID of the desired TidalPool containing this TidalPod
Required
podId*
String
The ID of the desired TidalPod to return stats about
Required

Responses

Status: 200 - OK

Status: 404 - Unable to find Quickstats for that TidalPod

Status: 500 - Internal Server Error


getPods

List the TidalPods in a TidalPool


/pools/{poolId}/pods

Usage and SDK Samples

curl -X GET "https://api.tidalscale.com/v1/pools/{poolId}/pods"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PodsApi;

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

public class PodsApiExample {

    public static void main(String[] args) {
        
        PodsApi apiInstance = new PodsApi();
        String poolId = poolId_example; // String | The ID of the desired TidalPool containing these TidalPods
        try {
            array[inline_response_200_3] result = apiInstance.getPods(poolId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PodsApi#getPods");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.PodsApi;

public class PodsApiExample {

    public static void main(String[] args) {
        PodsApi apiInstance = new PodsApi();
        String poolId = poolId_example; // String | The ID of the desired TidalPool containing these TidalPods
        try {
            array[inline_response_200_3] result = apiInstance.getPods(poolId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PodsApi#getPods");
            e.printStackTrace();
        }
    }
}
String *poolId = poolId_example; // The ID of the desired TidalPool containing these TidalPods

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

// List the TidalPods in a TidalPool
[apiInstance getPodsWith:poolId
              completionHandler: ^(array[inline_response_200_3] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WaveRunnerApi = require('wave_runner_api');

var api = new WaveRunnerApi.PodsApi()

var poolId = poolId_example; // {String} The ID of the desired TidalPool containing these TidalPods


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

namespace Example
{
    public class getPodsExample
    {
        public void main()
        {
            
            var apiInstance = new PodsApi();
            var poolId = poolId_example;  // String | The ID of the desired TidalPool containing these TidalPods

            try
            {
                // List the TidalPods in a TidalPool
                array[inline_response_200_3] result = apiInstance.getPods(poolId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PodsApi.getPods: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\PodsApi();
$poolId = poolId_example; // String | The ID of the desired TidalPool containing these TidalPods

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

my $api_instance = WWW::SwaggerClient::PodsApi->new();
my $poolId = poolId_example; # String | The ID of the desired TidalPool containing these TidalPods

eval { 
    my $result = $api_instance->getPods(poolId => $poolId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PodsApi->getPods: $@\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.PodsApi()
poolId = poolId_example # String | The ID of the desired TidalPool containing these TidalPods

try: 
    # List the TidalPods in a TidalPool
    api_response = api_instance.get_pods(poolId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PodsApi->getPods: %s\n" % e)

Parameters

Path parameters
Name Description
poolId*
String
The ID of the desired TidalPool containing these TidalPods
Required

Responses

Status: 200 - OK

Status: 404 - No TidalPods associated with that TidalPool

Status: 500 - Internal Server Error


getPoolsPoolIdPodsPodIdConsole

Return a TidalPod console


/pools/{poolId}/pods/{podId}/console

Usage and SDK Samples

curl -X GET "https://api.tidalscale.com/v1/pools/{poolId}/pods/{podId}/console"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PodsApi;

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

public class PodsApiExample {

    public static void main(String[] args) {
        
        PodsApi apiInstance = new PodsApi();
        String poolId = poolId_example; // String | ID that belongs to TidalPool
        String podId = podId_example; // String | ID that belongs to a TidalPod
        try {
            apiInstance.getPoolsPoolIdPodsPodIdConsole(poolId, podId);
        } catch (ApiException e) {
            System.err.println("Exception when calling PodsApi#getPoolsPoolIdPodsPodIdConsole");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.PodsApi;

public class PodsApiExample {

    public static void main(String[] args) {
        PodsApi apiInstance = new PodsApi();
        String poolId = poolId_example; // String | ID that belongs to TidalPool
        String podId = podId_example; // String | ID that belongs to a TidalPod
        try {
            apiInstance.getPoolsPoolIdPodsPodIdConsole(poolId, podId);
        } catch (ApiException e) {
            System.err.println("Exception when calling PodsApi#getPoolsPoolIdPodsPodIdConsole");
            e.printStackTrace();
        }
    }
}
String *poolId = poolId_example; // ID that belongs to TidalPool
String *podId = podId_example; // ID that belongs to a TidalPod

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

// Return a TidalPod console
[apiInstance getPoolsPoolIdPodsPodIdConsoleWith:poolId
    podId:podId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WaveRunnerApi = require('wave_runner_api');

var api = new WaveRunnerApi.PodsApi()

var poolId = poolId_example; // {String} ID that belongs to TidalPool

var podId = podId_example; // {String} ID that belongs to a TidalPod


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

namespace Example
{
    public class getPoolsPoolIdPodsPodIdConsoleExample
    {
        public void main()
        {
            
            var apiInstance = new PodsApi();
            var poolId = poolId_example;  // String | ID that belongs to TidalPool
            var podId = podId_example;  // String | ID that belongs to a TidalPod

            try
            {
                // Return a TidalPod console
                apiInstance.getPoolsPoolIdPodsPodIdConsole(poolId, podId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PodsApi.getPoolsPoolIdPodsPodIdConsole: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\PodsApi();
$poolId = poolId_example; // String | ID that belongs to TidalPool
$podId = podId_example; // String | ID that belongs to a TidalPod

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

my $api_instance = WWW::SwaggerClient::PodsApi->new();
my $poolId = poolId_example; # String | ID that belongs to TidalPool
my $podId = podId_example; # String | ID that belongs to a TidalPod

eval { 
    $api_instance->getPoolsPoolIdPodsPodIdConsole(poolId => $poolId, podId => $podId);
};
if ($@) {
    warn "Exception when calling PodsApi->getPoolsPoolIdPodsPodIdConsole: $@\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.PodsApi()
poolId = poolId_example # String | ID that belongs to TidalPool
podId = podId_example # String | ID that belongs to a TidalPod

try: 
    # Return a TidalPod console
    api_instance.get_pools_pool_id_pods_pod_id_console(poolId, podId)
except ApiException as e:
    print("Exception when calling PodsApi->getPoolsPoolIdPodsPodIdConsole: %s\n" % e)

Parameters

Path parameters
Name Description
poolId*
String
ID that belongs to TidalPool
Required
podId*
String
ID that belongs to a TidalPod
Required

Responses

Status: 200 - OK

Status: 404 - Unable to get Console for that TidalPod

Status: 500 - Internal Server Error


getPoolsPoolIdPodsPodIdGuest

Get a TidalPod's most recent VM in use


/pools/{poolId}/pods/{podId}/guest

Usage and SDK Samples

curl -X GET "https://api.tidalscale.com/v1/pools/{poolId}/pods/{podId}/guest"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PodsApi;

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

public class PodsApiExample {

    public static void main(String[] args) {
        
        PodsApi apiInstance = new PodsApi();
        String poolId = poolId_example; // String | The ID of the desired TidalPool containing this TidalPod
        String podId = podId_example; // String | The ID of the desired TidalPod containing this Node
        try {
            inline_response_201 result = apiInstance.getPoolsPoolIdPodsPodIdGuest(poolId, podId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PodsApi#getPoolsPoolIdPodsPodIdGuest");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.PodsApi;

public class PodsApiExample {

    public static void main(String[] args) {
        PodsApi apiInstance = new PodsApi();
        String poolId = poolId_example; // String | The ID of the desired TidalPool containing this TidalPod
        String podId = podId_example; // String | The ID of the desired TidalPod containing this Node
        try {
            inline_response_201 result = apiInstance.getPoolsPoolIdPodsPodIdGuest(poolId, podId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PodsApi#getPoolsPoolIdPodsPodIdGuest");
            e.printStackTrace();
        }
    }
}
String *poolId = poolId_example; // The ID of the desired TidalPool containing this TidalPod
String *podId = podId_example; // The ID of the desired TidalPod containing this Node

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

// Get a TidalPod's most recent VM in use
[apiInstance getPoolsPoolIdPodsPodIdGuestWith:poolId
    podId:podId
              completionHandler: ^(inline_response_201 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WaveRunnerApi = require('wave_runner_api');

var api = new WaveRunnerApi.PodsApi()

var poolId = poolId_example; // {String} The ID of the desired TidalPool containing this TidalPod

var podId = podId_example; // {String} The ID of the desired TidalPod containing this Node


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

namespace Example
{
    public class getPoolsPoolIdPodsPodIdGuestExample
    {
        public void main()
        {
            
            var apiInstance = new PodsApi();
            var poolId = poolId_example;  // String | The ID of the desired TidalPool containing this TidalPod
            var podId = podId_example;  // String | The ID of the desired TidalPod containing this Node

            try
            {
                // Get a TidalPod's most recent VM in use
                inline_response_201 result = apiInstance.getPoolsPoolIdPodsPodIdGuest(poolId, podId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PodsApi.getPoolsPoolIdPodsPodIdGuest: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\PodsApi();
$poolId = poolId_example; // String | The ID of the desired TidalPool containing this TidalPod
$podId = podId_example; // String | The ID of the desired TidalPod containing this Node

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

my $api_instance = WWW::SwaggerClient::PodsApi->new();
my $poolId = poolId_example; # String | The ID of the desired TidalPool containing this TidalPod
my $podId = podId_example; # String | The ID of the desired TidalPod containing this Node

eval { 
    my $result = $api_instance->getPoolsPoolIdPodsPodIdGuest(poolId => $poolId, podId => $podId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PodsApi->getPoolsPoolIdPodsPodIdGuest: $@\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.PodsApi()
poolId = poolId_example # String | The ID of the desired TidalPool containing this TidalPod
podId = podId_example # String | The ID of the desired TidalPod containing this Node

try: 
    # Get a TidalPod's most recent VM in use
    api_response = api_instance.get_pools_pool_id_pods_pod_id_guest(poolId, podId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PodsApi->getPoolsPoolIdPodsPodIdGuest: %s\n" % e)

Parameters

Path parameters
Name Description
poolId*
String
The ID of the desired TidalPool containing this TidalPod
Required
podId*
String
The ID of the desired TidalPod containing this Node
Required

Responses

Status: 201 - OK

Status: 404 - Unable to get VM for the identified TidalPod

Status: 500 - Internal Server Error


getPoolsPoolIdPodsPodIdGuestcommand

TidalPod guestconsole

Returns the guestcommand for a TidalPod


/pools/{poolId}/pods/{podId}/guestcommand

Usage and SDK Samples

curl -X GET "https://api.tidalscale.com/v1/pools/{poolId}/pods/{podId}/guestcommand"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PodsApi;

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

public class PodsApiExample {

    public static void main(String[] args) {
        
        PodsApi apiInstance = new PodsApi();
        String poolId = poolId_example; // String | ID that belongs to TidalPool
        String podId = podId_example; // String | ID that belongs to a TidalPod
        try {
            apiInstance.getPoolsPoolIdPodsPodIdGuestcommand(poolId, podId);
        } catch (ApiException e) {
            System.err.println("Exception when calling PodsApi#getPoolsPoolIdPodsPodIdGuestcommand");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.PodsApi;

public class PodsApiExample {

    public static void main(String[] args) {
        PodsApi apiInstance = new PodsApi();
        String poolId = poolId_example; // String | ID that belongs to TidalPool
        String podId = podId_example; // String | ID that belongs to a TidalPod
        try {
            apiInstance.getPoolsPoolIdPodsPodIdGuestcommand(poolId, podId);
        } catch (ApiException e) {
            System.err.println("Exception when calling PodsApi#getPoolsPoolIdPodsPodIdGuestcommand");
            e.printStackTrace();
        }
    }
}
String *poolId = poolId_example; // ID that belongs to TidalPool
String *podId = podId_example; // ID that belongs to a TidalPod

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

// TidalPod guestconsole
[apiInstance getPoolsPoolIdPodsPodIdGuestcommandWith:poolId
    podId:podId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WaveRunnerApi = require('wave_runner_api');

var api = new WaveRunnerApi.PodsApi()

var poolId = poolId_example; // {String} ID that belongs to TidalPool

var podId = podId_example; // {String} ID that belongs to a TidalPod


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

namespace Example
{
    public class getPoolsPoolIdPodsPodIdGuestcommandExample
    {
        public void main()
        {
            
            var apiInstance = new PodsApi();
            var poolId = poolId_example;  // String | ID that belongs to TidalPool
            var podId = podId_example;  // String | ID that belongs to a TidalPod

            try
            {
                // TidalPod guestconsole
                apiInstance.getPoolsPoolIdPodsPodIdGuestcommand(poolId, podId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PodsApi.getPoolsPoolIdPodsPodIdGuestcommand: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\PodsApi();
$poolId = poolId_example; // String | ID that belongs to TidalPool
$podId = podId_example; // String | ID that belongs to a TidalPod

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

my $api_instance = WWW::SwaggerClient::PodsApi->new();
my $poolId = poolId_example; # String | ID that belongs to TidalPool
my $podId = podId_example; # String | ID that belongs to a TidalPod

eval { 
    $api_instance->getPoolsPoolIdPodsPodIdGuestcommand(poolId => $poolId, podId => $podId);
};
if ($@) {
    warn "Exception when calling PodsApi->getPoolsPoolIdPodsPodIdGuestcommand: $@\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.PodsApi()
poolId = poolId_example # String | ID that belongs to TidalPool
podId = podId_example # String | ID that belongs to a TidalPod

try: 
    # TidalPod guestconsole
    api_instance.get_pools_pool_id_pods_pod_id_guestcommand(poolId, podId)
except ApiException as e:
    print("Exception when calling PodsApi->getPoolsPoolIdPodsPodIdGuestcommand: %s\n" % e)

Parameters

Path parameters
Name Description
poolId*
String
ID that belongs to TidalPool
Required
podId*
String
ID that belongs to a TidalPod
Required

Responses

Status: 200 - Successfully received TidalPod guestcommand

Status: 404 - Unable to get guestcommand for that TidalPod

Status: 500 - Internal Server Error


getPoolsPoolIdPodsPodIdGuestconsole

TidalPod guestconsole

Returns the guestconsole for a TidalPod


/pools/{poolId}/pods/{podId}/guestconsole

Usage and SDK Samples

curl -X GET "https://api.tidalscale.com/v1/pools/{poolId}/pods/{podId}/guestconsole"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PodsApi;

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

public class PodsApiExample {

    public static void main(String[] args) {
        
        PodsApi apiInstance = new PodsApi();
        String poolId = poolId_example; // String | ID that belongs to TidalPool
        String podId = podId_example; // String | ID that belongs to a TidalPod
        try {
            apiInstance.getPoolsPoolIdPodsPodIdGuestconsole(poolId, podId);
        } catch (ApiException e) {
            System.err.println("Exception when calling PodsApi#getPoolsPoolIdPodsPodIdGuestconsole");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.PodsApi;

public class PodsApiExample {

    public static void main(String[] args) {
        PodsApi apiInstance = new PodsApi();
        String poolId = poolId_example; // String | ID that belongs to TidalPool
        String podId = podId_example; // String | ID that belongs to a TidalPod
        try {
            apiInstance.getPoolsPoolIdPodsPodIdGuestconsole(poolId, podId);
        } catch (ApiException e) {
            System.err.println("Exception when calling PodsApi#getPoolsPoolIdPodsPodIdGuestconsole");
            e.printStackTrace();
        }
    }
}
String *poolId = poolId_example; // ID that belongs to TidalPool
String *podId = podId_example; // ID that belongs to a TidalPod

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

// TidalPod guestconsole
[apiInstance getPoolsPoolIdPodsPodIdGuestconsoleWith:poolId
    podId:podId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WaveRunnerApi = require('wave_runner_api');

var api = new WaveRunnerApi.PodsApi()

var poolId = poolId_example; // {String} ID that belongs to TidalPool

var podId = podId_example; // {String} ID that belongs to a TidalPod


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

namespace Example
{
    public class getPoolsPoolIdPodsPodIdGuestconsoleExample
    {
        public void main()
        {
            
            var apiInstance = new PodsApi();
            var poolId = poolId_example;  // String | ID that belongs to TidalPool
            var podId = podId_example;  // String | ID that belongs to a TidalPod

            try
            {
                // TidalPod guestconsole
                apiInstance.getPoolsPoolIdPodsPodIdGuestconsole(poolId, podId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PodsApi.getPoolsPoolIdPodsPodIdGuestconsole: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\PodsApi();
$poolId = poolId_example; // String | ID that belongs to TidalPool
$podId = podId_example; // String | ID that belongs to a TidalPod

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

my $api_instance = WWW::SwaggerClient::PodsApi->new();
my $poolId = poolId_example; # String | ID that belongs to TidalPool
my $podId = podId_example; # String | ID that belongs to a TidalPod

eval { 
    $api_instance->getPoolsPoolIdPodsPodIdGuestconsole(poolId => $poolId, podId => $podId);
};
if ($@) {
    warn "Exception when calling PodsApi->getPoolsPoolIdPodsPodIdGuestconsole: $@\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.PodsApi()
poolId = poolId_example # String | ID that belongs to TidalPool
podId = podId_example # String | ID that belongs to a TidalPod

try: 
    # TidalPod guestconsole
    api_instance.get_pools_pool_id_pods_pod_id_guestconsole(poolId, podId)
except ApiException as e:
    print("Exception when calling PodsApi->getPoolsPoolIdPodsPodIdGuestconsole: %s\n" % e)

Parameters

Path parameters
Name Description
poolId*
String
ID that belongs to TidalPool
Required
podId*
String
ID that belongs to a TidalPod
Required

Responses

Status: 200 - Successfully received TidalPod guestconsole

Status: 404 - Guestconsole not found for that TidalPod

Status: 500 - Internal Server Error


getPoolsPoolIdPodsPodIdGuestshell

TidalPod guestshell

Returns the guestshell for a TidalPod


/pools/{poolId}/pods/{podId}/guestshell

Usage and SDK Samples

curl -X GET "https://api.tidalscale.com/v1/pools/{poolId}/pods/{podId}/guestshell"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PodsApi;

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

public class PodsApiExample {

    public static void main(String[] args) {
        
        PodsApi apiInstance = new PodsApi();
        String poolId = poolId_example; // String | ID that belongs to TidalPool
        String podId = podId_example; // String | ID that belongs to a TidalPod
        try {
            apiInstance.getPoolsPoolIdPodsPodIdGuestshell(poolId, podId);
        } catch (ApiException e) {
            System.err.println("Exception when calling PodsApi#getPoolsPoolIdPodsPodIdGuestshell");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.PodsApi;

public class PodsApiExample {

    public static void main(String[] args) {
        PodsApi apiInstance = new PodsApi();
        String poolId = poolId_example; // String | ID that belongs to TidalPool
        String podId = podId_example; // String | ID that belongs to a TidalPod
        try {
            apiInstance.getPoolsPoolIdPodsPodIdGuestshell(poolId, podId);
        } catch (ApiException e) {
            System.err.println("Exception when calling PodsApi#getPoolsPoolIdPodsPodIdGuestshell");
            e.printStackTrace();
        }
    }
}
String *poolId = poolId_example; // ID that belongs to TidalPool
String *podId = podId_example; // ID that belongs to a TidalPod

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

// TidalPod guestshell
[apiInstance getPoolsPoolIdPodsPodIdGuestshellWith:poolId
    podId:podId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WaveRunnerApi = require('wave_runner_api');

var api = new WaveRunnerApi.PodsApi()

var poolId = poolId_example; // {String} ID that belongs to TidalPool

var podId = podId_example; // {String} ID that belongs to a TidalPod


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

namespace Example
{
    public class getPoolsPoolIdPodsPodIdGuestshellExample
    {
        public void main()
        {
            
            var apiInstance = new PodsApi();
            var poolId = poolId_example;  // String | ID that belongs to TidalPool
            var podId = podId_example;  // String | ID that belongs to a TidalPod

            try
            {
                // TidalPod guestshell
                apiInstance.getPoolsPoolIdPodsPodIdGuestshell(poolId, podId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PodsApi.getPoolsPoolIdPodsPodIdGuestshell: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\PodsApi();
$poolId = poolId_example; // String | ID that belongs to TidalPool
$podId = podId_example; // String | ID that belongs to a TidalPod

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

my $api_instance = WWW::SwaggerClient::PodsApi->new();
my $poolId = poolId_example; # String | ID that belongs to TidalPool
my $podId = podId_example; # String | ID that belongs to a TidalPod

eval { 
    $api_instance->getPoolsPoolIdPodsPodIdGuestshell(poolId => $poolId, podId => $podId);
};
if ($@) {
    warn "Exception when calling PodsApi->getPoolsPoolIdPodsPodIdGuestshell: $@\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.PodsApi()
poolId = poolId_example # String | ID that belongs to TidalPool
podId = podId_example # String | ID that belongs to a TidalPod

try: 
    # TidalPod guestshell
    api_instance.get_pools_pool_id_pods_pod_id_guestshell(poolId, podId)
except ApiException as e:
    print("Exception when calling PodsApi->getPoolsPoolIdPodsPodIdGuestshell: %s\n" % e)

Parameters

Path parameters
Name Description
poolId*
String
ID that belongs to TidalPool
Required
podId*
String
ID that belongs to a TidalPod
Required

Responses

Status: 200 - Successfully received TidalPod guestshell

Status: 404 - Unable to get guestshell for the identified TidalPod

Status: 500 - Internal Server Error


getPoolsPoolIdPodsPodIdOptions

Get TidalPod options

Returns options for a TidalPod


/pools/{poolId}/pods/{podId}/options

Usage and SDK Samples

curl -X GET "https://api.tidalscale.com/v1/pools/{poolId}/pods/{podId}/options"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PodsApi;

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

public class PodsApiExample {

    public static void main(String[] args) {
        
        PodsApi apiInstance = new PodsApi();
        String poolId = poolId_example; // String | ID that belongs to TidalPool
        String podId = podId_example; // String | ID that belongs to a TidalPod
        try {
            apiInstance.getPoolsPoolIdPodsPodIdOptions(poolId, podId);
        } catch (ApiException e) {
            System.err.println("Exception when calling PodsApi#getPoolsPoolIdPodsPodIdOptions");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.PodsApi;

public class PodsApiExample {

    public static void main(String[] args) {
        PodsApi apiInstance = new PodsApi();
        String poolId = poolId_example; // String | ID that belongs to TidalPool
        String podId = podId_example; // String | ID that belongs to a TidalPod
        try {
            apiInstance.getPoolsPoolIdPodsPodIdOptions(poolId, podId);
        } catch (ApiException e) {
            System.err.println("Exception when calling PodsApi#getPoolsPoolIdPodsPodIdOptions");
            e.printStackTrace();
        }
    }
}
String *poolId = poolId_example; // ID that belongs to TidalPool
String *podId = podId_example; // ID that belongs to a TidalPod

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

// Get TidalPod options
[apiInstance getPoolsPoolIdPodsPodIdOptionsWith:poolId
    podId:podId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WaveRunnerApi = require('wave_runner_api');

var api = new WaveRunnerApi.PodsApi()

var poolId = poolId_example; // {String} ID that belongs to TidalPool

var podId = podId_example; // {String} ID that belongs to a TidalPod


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

namespace Example
{
    public class getPoolsPoolIdPodsPodIdOptionsExample
    {
        public void main()
        {
            
            var apiInstance = new PodsApi();
            var poolId = poolId_example;  // String | ID that belongs to TidalPool
            var podId = podId_example;  // String | ID that belongs to a TidalPod

            try
            {
                // Get TidalPod options
                apiInstance.getPoolsPoolIdPodsPodIdOptions(poolId, podId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PodsApi.getPoolsPoolIdPodsPodIdOptions: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\PodsApi();
$poolId = poolId_example; // String | ID that belongs to TidalPool
$podId = podId_example; // String | ID that belongs to a TidalPod

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

my $api_instance = WWW::SwaggerClient::PodsApi->new();
my $poolId = poolId_example; # String | ID that belongs to TidalPool
my $podId = podId_example; # String | ID that belongs to a TidalPod

eval { 
    $api_instance->getPoolsPoolIdPodsPodIdOptions(poolId => $poolId, podId => $podId);
};
if ($@) {
    warn "Exception when calling PodsApi->getPoolsPoolIdPodsPodIdOptions: $@\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.PodsApi()
poolId = poolId_example # String | ID that belongs to TidalPool
podId = podId_example # String | ID that belongs to a TidalPod

try: 
    # Get TidalPod options
    api_instance.get_pools_pool_id_pods_pod_id_options(poolId, podId)
except ApiException as e:
    print("Exception when calling PodsApi->getPoolsPoolIdPodsPodIdOptions: %s\n" % e)

Parameters

Path parameters
Name Description
poolId*
String
ID that belongs to TidalPool
Required
podId*
String
ID that belongs to a TidalPod
Required

Responses

Status: 200 - Successfully received TidalPod options

Status: 404 - Unable to get options for the identified TidalPod

Status: 500 - Internal Server Error


getPoolsPoolIdPodsPodIdPerfplot

Get a TidalPod's perfplot

Returns perfplot for a TidalPod


/pools/{poolId}/pods/{podId}/perfplot

Usage and SDK Samples

curl -X GET "https://api.tidalscale.com/v1/pools/{poolId}/pods/{podId}/perfplot"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PodsApi;

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

public class PodsApiExample {

    public static void main(String[] args) {
        
        PodsApi apiInstance = new PodsApi();
        String poolId = poolId_example; // String | ID that belongs to TidalPool
        String podId = podId_example; // String | ID that belongs to a TidalPod
        try {
            apiInstance.getPoolsPoolIdPodsPodIdPerfplot(poolId, podId);
        } catch (ApiException e) {
            System.err.println("Exception when calling PodsApi#getPoolsPoolIdPodsPodIdPerfplot");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.PodsApi;

public class PodsApiExample {

    public static void main(String[] args) {
        PodsApi apiInstance = new PodsApi();
        String poolId = poolId_example; // String | ID that belongs to TidalPool
        String podId = podId_example; // String | ID that belongs to a TidalPod
        try {
            apiInstance.getPoolsPoolIdPodsPodIdPerfplot(poolId, podId);
        } catch (ApiException e) {
            System.err.println("Exception when calling PodsApi#getPoolsPoolIdPodsPodIdPerfplot");
            e.printStackTrace();
        }
    }
}
String *poolId = poolId_example; // ID that belongs to TidalPool
String *podId = podId_example; // ID that belongs to a TidalPod

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

// Get a TidalPod's perfplot
[apiInstance getPoolsPoolIdPodsPodIdPerfplotWith:poolId
    podId:podId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WaveRunnerApi = require('wave_runner_api');

var api = new WaveRunnerApi.PodsApi()

var poolId = poolId_example; // {String} ID that belongs to TidalPool

var podId = podId_example; // {String} ID that belongs to a TidalPod


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

namespace Example
{
    public class getPoolsPoolIdPodsPodIdPerfplotExample
    {
        public void main()
        {
            
            var apiInstance = new PodsApi();
            var poolId = poolId_example;  // String | ID that belongs to TidalPool
            var podId = podId_example;  // String | ID that belongs to a TidalPod

            try
            {
                // Get a TidalPod's perfplot
                apiInstance.getPoolsPoolIdPodsPodIdPerfplot(poolId, podId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PodsApi.getPoolsPoolIdPodsPodIdPerfplot: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\PodsApi();
$poolId = poolId_example; // String | ID that belongs to TidalPool
$podId = podId_example; // String | ID that belongs to a TidalPod

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

my $api_instance = WWW::SwaggerClient::PodsApi->new();
my $poolId = poolId_example; # String | ID that belongs to TidalPool
my $podId = podId_example; # String | ID that belongs to a TidalPod

eval { 
    $api_instance->getPoolsPoolIdPodsPodIdPerfplot(poolId => $poolId, podId => $podId);
};
if ($@) {
    warn "Exception when calling PodsApi->getPoolsPoolIdPodsPodIdPerfplot: $@\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.PodsApi()
poolId = poolId_example # String | ID that belongs to TidalPool
podId = podId_example # String | ID that belongs to a TidalPod

try: 
    # Get a TidalPod's perfplot
    api_instance.get_pools_pool_id_pods_pod_id_perfplot(poolId, podId)
except ApiException as e:
    print("Exception when calling PodsApi->getPoolsPoolIdPodsPodIdPerfplot: %s\n" % e)

Parameters

Path parameters
Name Description
poolId*
String
ID that belongs to TidalPool
Required
podId*
String
ID that belongs to a TidalPod
Required

Responses

Status: 200 - Successfully received TidalPod perfplot

Status: 404 - Unable to get perfplot for that TidalPod

Status: 500 - Internal Server Error


getPoolsPoolIdPodsPodIdPower

Get TidalPod power

Returns TidalPod power status


/pools/{poolId}/pods/{podId}/power

Usage and SDK Samples

curl -X GET "https://api.tidalscale.com/v1/pools/{poolId}/pods/{podId}/power"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PodsApi;

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

public class PodsApiExample {

    public static void main(String[] args) {
        
        PodsApi apiInstance = new PodsApi();
        String poolId = poolId_example; // String | ID that belongs to TidalPool
        String podId = podId_example; // String | ID that belongs to a TidalPod
        try {
            apiInstance.getPoolsPoolIdPodsPodIdPower(poolId, podId);
        } catch (ApiException e) {
            System.err.println("Exception when calling PodsApi#getPoolsPoolIdPodsPodIdPower");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.PodsApi;

public class PodsApiExample {

    public static void main(String[] args) {
        PodsApi apiInstance = new PodsApi();
        String poolId = poolId_example; // String | ID that belongs to TidalPool
        String podId = podId_example; // String | ID that belongs to a TidalPod
        try {
            apiInstance.getPoolsPoolIdPodsPodIdPower(poolId, podId);
        } catch (ApiException e) {
            System.err.println("Exception when calling PodsApi#getPoolsPoolIdPodsPodIdPower");
            e.printStackTrace();
        }
    }
}
String *poolId = poolId_example; // ID that belongs to TidalPool
String *podId = podId_example; // ID that belongs to a TidalPod

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

// Get TidalPod power
[apiInstance getPoolsPoolIdPodsPodIdPowerWith:poolId
    podId:podId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WaveRunnerApi = require('wave_runner_api');

var api = new WaveRunnerApi.PodsApi()

var poolId = poolId_example; // {String} ID that belongs to TidalPool

var podId = podId_example; // {String} ID that belongs to a TidalPod


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

namespace Example
{
    public class getPoolsPoolIdPodsPodIdPowerExample
    {
        public void main()
        {
            
            var apiInstance = new PodsApi();
            var poolId = poolId_example;  // String | ID that belongs to TidalPool
            var podId = podId_example;  // String | ID that belongs to a TidalPod

            try
            {
                // Get TidalPod power
                apiInstance.getPoolsPoolIdPodsPodIdPower(poolId, podId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PodsApi.getPoolsPoolIdPodsPodIdPower: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\PodsApi();
$poolId = poolId_example; // String | ID that belongs to TidalPool
$podId = podId_example; // String | ID that belongs to a TidalPod

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

my $api_instance = WWW::SwaggerClient::PodsApi->new();
my $poolId = poolId_example; # String | ID that belongs to TidalPool
my $podId = podId_example; # String | ID that belongs to a TidalPod

eval { 
    $api_instance->getPoolsPoolIdPodsPodIdPower(poolId => $poolId, podId => $podId);
};
if ($@) {
    warn "Exception when calling PodsApi->getPoolsPoolIdPodsPodIdPower: $@\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.PodsApi()
poolId = poolId_example # String | ID that belongs to TidalPool
podId = podId_example # String | ID that belongs to a TidalPod

try: 
    # Get TidalPod power
    api_instance.get_pools_pool_id_pods_pod_id_power(poolId, podId)
except ApiException as e:
    print("Exception when calling PodsApi->getPoolsPoolIdPodsPodIdPower: %s\n" % e)

Parameters

Path parameters
Name Description
poolId*
String
ID that belongs to TidalPool
Required
podId*
String
ID that belongs to a TidalPod
Required

Responses

Status: 200 - Successfully received TidalPod power status

Status: 404 - Unable to get TidalPod power status

Status: 500 - Internal Server Error


getPoolsPoolIdPodsPodIdPowerws

Get TidalPod power as WebSocket


/pools/{poolId}/pods/{podId}/powerws

Usage and SDK Samples

curl -X GET "https://api.tidalscale.com/v1/pools/{poolId}/pods/{podId}/powerws"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PodsApi;

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

public class PodsApiExample {

    public static void main(String[] args) {
        
        PodsApi apiInstance = new PodsApi();
        String poolId = poolId_example; // String | ID that belongs to TidalPool
        String podId = podId_example; // String | ID that belongs to a TidalPod
        try {
            apiInstance.getPoolsPoolIdPodsPodIdPowerws(poolId, podId);
        } catch (ApiException e) {
            System.err.println("Exception when calling PodsApi#getPoolsPoolIdPodsPodIdPowerws");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.PodsApi;

public class PodsApiExample {

    public static void main(String[] args) {
        PodsApi apiInstance = new PodsApi();
        String poolId = poolId_example; // String | ID that belongs to TidalPool
        String podId = podId_example; // String | ID that belongs to a TidalPod
        try {
            apiInstance.getPoolsPoolIdPodsPodIdPowerws(poolId, podId);
        } catch (ApiException e) {
            System.err.println("Exception when calling PodsApi#getPoolsPoolIdPodsPodIdPowerws");
            e.printStackTrace();
        }
    }
}
String *poolId = poolId_example; // ID that belongs to TidalPool
String *podId = podId_example; // ID that belongs to a TidalPod

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

// Get TidalPod power as WebSocket
[apiInstance getPoolsPoolIdPodsPodIdPowerwsWith:poolId
    podId:podId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WaveRunnerApi = require('wave_runner_api');

var api = new WaveRunnerApi.PodsApi()

var poolId = poolId_example; // {String} ID that belongs to TidalPool

var podId = podId_example; // {String} ID that belongs to a TidalPod


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

namespace Example
{
    public class getPoolsPoolIdPodsPodIdPowerwsExample
    {
        public void main()
        {
            
            var apiInstance = new PodsApi();
            var poolId = poolId_example;  // String | ID that belongs to TidalPool
            var podId = podId_example;  // String | ID that belongs to a TidalPod

            try
            {
                // Get TidalPod power as WebSocket
                apiInstance.getPoolsPoolIdPodsPodIdPowerws(poolId, podId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PodsApi.getPoolsPoolIdPodsPodIdPowerws: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\PodsApi();
$poolId = poolId_example; // String | ID that belongs to TidalPool
$podId = podId_example; // String | ID that belongs to a TidalPod

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

my $api_instance = WWW::SwaggerClient::PodsApi->new();
my $poolId = poolId_example; # String | ID that belongs to TidalPool
my $podId = podId_example; # String | ID that belongs to a TidalPod

eval { 
    $api_instance->getPoolsPoolIdPodsPodIdPowerws(poolId => $poolId, podId => $podId);
};
if ($@) {
    warn "Exception when calling PodsApi->getPoolsPoolIdPodsPodIdPowerws: $@\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.PodsApi()
poolId = poolId_example # String | ID that belongs to TidalPool
podId = podId_example # String | ID that belongs to a TidalPod

try: 
    # Get TidalPod power as WebSocket
    api_instance.get_pools_pool_id_pods_pod_id_powerws(poolId, podId)
except ApiException as e:
    print("Exception when calling PodsApi->getPoolsPoolIdPodsPodIdPowerws: %s\n" % e)

Parameters

Path parameters
Name Description
poolId*
String
ID that belongs to TidalPool
Required
podId*
String
ID that belongs to a TidalPod
Required

Responses

Status: 200 - OK

Status: 404 - Unable to find power websocket for that TidalPod

Status: 500 - Internal Server Error


getPoolsPoolIdPodsPodIdShell

Return a TidalPod shell


/pools/{poolId}/pods/{podId}/shell

Usage and SDK Samples

curl -X GET "https://api.tidalscale.com/v1/pools/{poolId}/pods/{podId}/shell"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PodsApi;

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

public class PodsApiExample {

    public static void main(String[] args) {
        
        PodsApi apiInstance = new PodsApi();
        String poolId = poolId_example; // String | ID that belongs to TidalPool
        String podId = podId_example; // String | ID that belongs to a TidalPod
        try {
            apiInstance.getPoolsPoolIdPodsPodIdShell(poolId, podId);
        } catch (ApiException e) {
            System.err.println("Exception when calling PodsApi#getPoolsPoolIdPodsPodIdShell");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.PodsApi;

public class PodsApiExample {

    public static void main(String[] args) {
        PodsApi apiInstance = new PodsApi();
        String poolId = poolId_example; // String | ID that belongs to TidalPool
        String podId = podId_example; // String | ID that belongs to a TidalPod
        try {
            apiInstance.getPoolsPoolIdPodsPodIdShell(poolId, podId);
        } catch (ApiException e) {
            System.err.println("Exception when calling PodsApi#getPoolsPoolIdPodsPodIdShell");
            e.printStackTrace();
        }
    }
}
String *poolId = poolId_example; // ID that belongs to TidalPool
String *podId = podId_example; // ID that belongs to a TidalPod

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

// Return a TidalPod shell
[apiInstance getPoolsPoolIdPodsPodIdShellWith:poolId
    podId:podId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WaveRunnerApi = require('wave_runner_api');

var api = new WaveRunnerApi.PodsApi()

var poolId = poolId_example; // {String} ID that belongs to TidalPool

var podId = podId_example; // {String} ID that belongs to a TidalPod


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

namespace Example
{
    public class getPoolsPoolIdPodsPodIdShellExample
    {
        public void main()
        {
            
            var apiInstance = new PodsApi();
            var poolId = poolId_example;  // String | ID that belongs to TidalPool
            var podId = podId_example;  // String | ID that belongs to a TidalPod

            try
            {
                // Return a TidalPod shell
                apiInstance.getPoolsPoolIdPodsPodIdShell(poolId, podId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PodsApi.getPoolsPoolIdPodsPodIdShell: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\PodsApi();
$poolId = poolId_example; // String | ID that belongs to TidalPool
$podId = podId_example; // String | ID that belongs to a TidalPod

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

my $api_instance = WWW::SwaggerClient::PodsApi->new();
my $poolId = poolId_example; # String | ID that belongs to TidalPool
my $podId = podId_example; # String | ID that belongs to a TidalPod

eval { 
    $api_instance->getPoolsPoolIdPodsPodIdShell(poolId => $poolId, podId => $podId);
};
if ($@) {
    warn "Exception when calling PodsApi->getPoolsPoolIdPodsPodIdShell: $@\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.PodsApi()
poolId = poolId_example # String | ID that belongs to TidalPool
podId = podId_example # String | ID that belongs to a TidalPod

try: 
    # Return a TidalPod shell
    api_instance.get_pools_pool_id_pods_pod_id_shell(poolId, podId)
except ApiException as e:
    print("Exception when calling PodsApi->getPoolsPoolIdPodsPodIdShell: %s\n" % e)

Parameters

Path parameters
Name Description
poolId*
String
ID that belongs to TidalPool
Required
podId*
String
ID that belongs to a TidalPod
Required

Responses

Status: 200 - OK

Status: 404 - Unable to get Shell for that TidalPod

Status: 500 - Internal Server Error


migratePod

Transfer a TidalPod to another TidalPool

This meethod abstractly moves a TidalPod to a different TidalPool. Currently different TidalPools share similar hardware resources, like switches, but this is not a requirement, so as their sizes expand it will mean that the TidalPod will move to different hardware and get its settings reconfigured.


/pools/{poolId}/pods/{podId}//migrate/{destinationPoolId}

Usage and SDK Samples

curl -X POST "https://api.tidalscale.com/v1/pools/{poolId}/pods/{podId}//migrate/{destinationPoolId}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PodsApi;

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

public class PodsApiExample {

    public static void main(String[] args) {
        
        PodsApi apiInstance = new PodsApi();
        String poolId = poolId_example; // String | The ID of the desired TidalPool containing the TidalPod
        String podId = podId_example; // String | The ID of the desired TidalPod containing these Nodes
        String destinationPoolId = destinationPoolId_example; // String | The ID of the desired TidalPool to migrate the TidalPod to. `destinationPoolId` is a UUID.
        try {
            inline_response_200_3 result = apiInstance.migratePod(poolId, podId, destinationPoolId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PodsApi#migratePod");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.PodsApi;

public class PodsApiExample {

    public static void main(String[] args) {
        PodsApi apiInstance = new PodsApi();
        String poolId = poolId_example; // String | The ID of the desired TidalPool containing the TidalPod
        String podId = podId_example; // String | The ID of the desired TidalPod containing these Nodes
        String destinationPoolId = destinationPoolId_example; // String | The ID of the desired TidalPool to migrate the TidalPod to. `destinationPoolId` is a UUID.
        try {
            inline_response_200_3 result = apiInstance.migratePod(poolId, podId, destinationPoolId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PodsApi#migratePod");
            e.printStackTrace();
        }
    }
}
String *poolId = poolId_example; // The ID of the desired TidalPool containing the TidalPod
String *podId = podId_example; // The ID of the desired TidalPod containing these Nodes
String *destinationPoolId = destinationPoolId_example; // The ID of the desired TidalPool to migrate the TidalPod to. `destinationPoolId` is a UUID.

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

// Transfer a TidalPod to another TidalPool
[apiInstance migratePodWith:poolId
    podId:podId
    destinationPoolId:destinationPoolId
              completionHandler: ^(inline_response_200_3 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WaveRunnerApi = require('wave_runner_api');

var api = new WaveRunnerApi.PodsApi()

var poolId = poolId_example; // {String} The ID of the desired TidalPool containing the TidalPod

var podId = podId_example; // {String} The ID of the desired TidalPod containing these Nodes

var destinationPoolId = destinationPoolId_example; // {String} The ID of the desired TidalPool to migrate the TidalPod to. `destinationPoolId` is a UUID.


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

namespace Example
{
    public class migratePodExample
    {
        public void main()
        {
            
            var apiInstance = new PodsApi();
            var poolId = poolId_example;  // String | The ID of the desired TidalPool containing the TidalPod
            var podId = podId_example;  // String | The ID of the desired TidalPod containing these Nodes
            var destinationPoolId = destinationPoolId_example;  // String | The ID of the desired TidalPool to migrate the TidalPod to. `destinationPoolId` is a UUID.

            try
            {
                // Transfer a TidalPod to another TidalPool
                inline_response_200_3 result = apiInstance.migratePod(poolId, podId, destinationPoolId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PodsApi.migratePod: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\PodsApi();
$poolId = poolId_example; // String | The ID of the desired TidalPool containing the TidalPod
$podId = podId_example; // String | The ID of the desired TidalPod containing these Nodes
$destinationPoolId = destinationPoolId_example; // String | The ID of the desired TidalPool to migrate the TidalPod to. `destinationPoolId` is a UUID.

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

my $api_instance = WWW::SwaggerClient::PodsApi->new();
my $poolId = poolId_example; # String | The ID of the desired TidalPool containing the TidalPod
my $podId = podId_example; # String | The ID of the desired TidalPod containing these Nodes
my $destinationPoolId = destinationPoolId_example; # String | The ID of the desired TidalPool to migrate the TidalPod to. `destinationPoolId` is a UUID.

eval { 
    my $result = $api_instance->migratePod(poolId => $poolId, podId => $podId, destinationPoolId => $destinationPoolId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PodsApi->migratePod: $@\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.PodsApi()
poolId = poolId_example # String | The ID of the desired TidalPool containing the TidalPod
podId = podId_example # String | The ID of the desired TidalPod containing these Nodes
destinationPoolId = destinationPoolId_example # String | The ID of the desired TidalPool to migrate the TidalPod to. `destinationPoolId` is a UUID.

try: 
    # Transfer a TidalPod to another TidalPool
    api_response = api_instance.migrate_pod(poolId, podId, destinationPoolId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PodsApi->migratePod: %s\n" % e)

Parameters

Path parameters
Name Description
poolId*
String
The ID of the desired TidalPool containing the TidalPod
Required
podId*
String
The ID of the desired TidalPod containing these Nodes
Required
destinationPoolId*
String
The ID of the desired TidalPool to migrate the TidalPod to. `destinationPoolId` is a UUID.
Required

Responses

Status: 200 - OK

Status: 404 - Unable to migrate TidalPod, one or more required resources not found

Status: 500 - Internal Server Error


patchPoolsPoolIdPodsPodId

Update a TidalPod

update TidalPod using given specifications


/pools/{poolId}/pods/{podId}

Usage and SDK Samples

curl -X PATCH "https://api.tidalscale.com/v1/pools/{poolId}/pods/{podId}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PodsApi;

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

public class PodsApiExample {

    public static void main(String[] args) {
        
        PodsApi apiInstance = new PodsApi();
        String poolId = poolId_example; // String | ID that belongs to TidalPool
        String podId = podId_example; // String | ID that belongs to a TidalPod
        Patch requirement_1 patch requirement = ; // Patch requirement_1 | 
        try {
            apiInstance.patchPoolsPoolIdPodsPodId(poolId, podId, patch requirement);
        } catch (ApiException e) {
            System.err.println("Exception when calling PodsApi#patchPoolsPoolIdPodsPodId");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.PodsApi;

public class PodsApiExample {

    public static void main(String[] args) {
        PodsApi apiInstance = new PodsApi();
        String poolId = poolId_example; // String | ID that belongs to TidalPool
        String podId = podId_example; // String | ID that belongs to a TidalPod
        Patch requirement_1 patch requirement = ; // Patch requirement_1 | 
        try {
            apiInstance.patchPoolsPoolIdPodsPodId(poolId, podId, patch requirement);
        } catch (ApiException e) {
            System.err.println("Exception when calling PodsApi#patchPoolsPoolIdPodsPodId");
            e.printStackTrace();
        }
    }
}
String *poolId = poolId_example; // ID that belongs to TidalPool
String *podId = podId_example; // ID that belongs to a TidalPod
Patch requirement_1 *patch requirement = ; //  (optional)

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

// Update a TidalPod
[apiInstance patchPoolsPoolIdPodsPodIdWith:poolId
    podId:podId
    patch requirement:patch requirement
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WaveRunnerApi = require('wave_runner_api');

var api = new WaveRunnerApi.PodsApi()

var poolId = poolId_example; // {String} ID that belongs to TidalPool

var podId = podId_example; // {String} ID that belongs to a TidalPod

var opts = { 
  'patch requirement':  // {Patch requirement_1} 
};

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

namespace Example
{
    public class patchPoolsPoolIdPodsPodIdExample
    {
        public void main()
        {
            
            var apiInstance = new PodsApi();
            var poolId = poolId_example;  // String | ID that belongs to TidalPool
            var podId = podId_example;  // String | ID that belongs to a TidalPod
            var patch requirement = new Patch requirement_1(); // Patch requirement_1 |  (optional) 

            try
            {
                // Update a TidalPod
                apiInstance.patchPoolsPoolIdPodsPodId(poolId, podId, patch requirement);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PodsApi.patchPoolsPoolIdPodsPodId: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\PodsApi();
$poolId = poolId_example; // String | ID that belongs to TidalPool
$podId = podId_example; // String | ID that belongs to a TidalPod
$patch requirement = ; // Patch requirement_1 | 

try {
    $api_instance->patchPoolsPoolIdPodsPodId($poolId, $podId, $patch requirement);
} catch (Exception $e) {
    echo 'Exception when calling PodsApi->patchPoolsPoolIdPodsPodId: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PodsApi;

my $api_instance = WWW::SwaggerClient::PodsApi->new();
my $poolId = poolId_example; # String | ID that belongs to TidalPool
my $podId = podId_example; # String | ID that belongs to a TidalPod
my $patch requirement = WWW::SwaggerClient::Object::Patch requirement_1->new(); # Patch requirement_1 | 

eval { 
    $api_instance->patchPoolsPoolIdPodsPodId(poolId => $poolId, podId => $podId, patch requirement => $patch requirement);
};
if ($@) {
    warn "Exception when calling PodsApi->patchPoolsPoolIdPodsPodId: $@\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.PodsApi()
poolId = poolId_example # String | ID that belongs to TidalPool
podId = podId_example # String | ID that belongs to a TidalPod
patch requirement =  # Patch requirement_1 |  (optional)

try: 
    # Update a TidalPod
    api_instance.patch_pools_pool_id_pods_pod_id(poolId, podId, patch requirement=patch requirement)
except ApiException as e:
    print("Exception when calling PodsApi->patchPoolsPoolIdPodsPodId: %s\n" % e)

Parameters

Path parameters
Name Description
poolId*
String
ID that belongs to TidalPool
Required
podId*
String
ID that belongs to a TidalPod
Required
Body parameters
Name Description
patch requirement

Responses

Status: 200 - Successfully updated TidalPod

Status: 400 - Error updating TidalPod. Modify values and try again.

Status: 500 - Internal Server Error


powerSwitchPodNodes

Power all Nodes in a TidalPod on or off

Effectively powers a TidalPod on or off Set status boolean for all Nodes' Power Status in the TidalPod to on (true) or off (false)


/pools/{poolId}/pods/{podId}/nodes/power

Usage and SDK Samples

curl -X POST "https://api.tidalscale.com/v1/pools/{poolId}/pods/{podId}/nodes/power"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PodsApi;

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

public class PodsApiExample {

    public static void main(String[] args) {
        
        PodsApi apiInstance = new PodsApi();
        String poolId = poolId_example; // String | The ID of the desired TidalPool containing the TidalPod
        String podId = podId_example; // String | The ID of the desired TidalPod containing these Nodes
        Status status = ; // Status | Set status boolean for all Nodes' Power Status in the TidalPod to on (true) or off (false)
        try {
            inline_response_201_1 result = apiInstance.powerSwitchPodNodes(poolId, podId, status);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PodsApi#powerSwitchPodNodes");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.PodsApi;

public class PodsApiExample {

    public static void main(String[] args) {
        PodsApi apiInstance = new PodsApi();
        String poolId = poolId_example; // String | The ID of the desired TidalPool containing the TidalPod
        String podId = podId_example; // String | The ID of the desired TidalPod containing these Nodes
        Status status = ; // Status | Set status boolean for all Nodes' Power Status in the TidalPod to on (true) or off (false)
        try {
            inline_response_201_1 result = apiInstance.powerSwitchPodNodes(poolId, podId, status);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PodsApi#powerSwitchPodNodes");
            e.printStackTrace();
        }
    }
}
String *poolId = poolId_example; // The ID of the desired TidalPool containing the TidalPod
String *podId = podId_example; // The ID of the desired TidalPod containing these Nodes
Status *status = ; // Set status boolean for all Nodes' Power Status in the TidalPod to on (true) or off (false)

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

// Power all Nodes in a TidalPod on or off
[apiInstance powerSwitchPodNodesWith:poolId
    podId:podId
    status:status
              completionHandler: ^(inline_response_201_1 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WaveRunnerApi = require('wave_runner_api');

var api = new WaveRunnerApi.PodsApi()

var poolId = poolId_example; // {String} The ID of the desired TidalPool containing the TidalPod

var podId = podId_example; // {String} The ID of the desired TidalPod containing these Nodes

var status = ; // {Status} Set status boolean for all Nodes' Power Status in the TidalPod to on (true) or off (false)


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

namespace Example
{
    public class powerSwitchPodNodesExample
    {
        public void main()
        {
            
            var apiInstance = new PodsApi();
            var poolId = poolId_example;  // String | The ID of the desired TidalPool containing the TidalPod
            var podId = podId_example;  // String | The ID of the desired TidalPod containing these Nodes
            var status = new Status(); // Status | Set status boolean for all Nodes' Power Status in the TidalPod to on (true) or off (false)

            try
            {
                // Power all Nodes in a TidalPod on or off
                inline_response_201_1 result = apiInstance.powerSwitchPodNodes(poolId, podId, status);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PodsApi.powerSwitchPodNodes: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\PodsApi();
$poolId = poolId_example; // String | The ID of the desired TidalPool containing the TidalPod
$podId = podId_example; // String | The ID of the desired TidalPod containing these Nodes
$status = ; // Status | Set status boolean for all Nodes' Power Status in the TidalPod to on (true) or off (false)

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

my $api_instance = WWW::SwaggerClient::PodsApi->new();
my $poolId = poolId_example; # String | The ID of the desired TidalPool containing the TidalPod
my $podId = podId_example; # String | The ID of the desired TidalPod containing these Nodes
my $status = WWW::SwaggerClient::Object::Status->new(); # Status | Set status boolean for all Nodes' Power Status in the TidalPod to on (true) or off (false)

eval { 
    my $result = $api_instance->powerSwitchPodNodes(poolId => $poolId, podId => $podId, status => $status);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PodsApi->powerSwitchPodNodes: $@\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.PodsApi()
poolId = poolId_example # String | The ID of the desired TidalPool containing the TidalPod
podId = podId_example # String | The ID of the desired TidalPod containing these Nodes
status =  # Status | Set status boolean for all Nodes' Power Status in the TidalPod to on (true) or off (false)

try: 
    # Power all Nodes in a TidalPod on or off
    api_response = api_instance.power_switch_pod_nodes(poolId, podId, status)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PodsApi->powerSwitchPodNodes: %s\n" % e)

Parameters

Path parameters
Name Description
poolId*
String
The ID of the desired TidalPool containing the TidalPod
Required
podId*
String
The ID of the desired TidalPod containing these Nodes
Required
Body parameters
Name Description
status *

Responses

Status: 201 - TidalPod power task

Status: 500 - Internal Server Error


Pools

createPool

Create a new TidalPool

Create a new TidalPool to partition new Nodes into


/pools

Usage and SDK Samples

curl -X POST "https://api.tidalscale.com/v1/pools"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PoolsApi;

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

public class PoolsApiExample {

    public static void main(String[] args) {
        
        PoolsApi apiInstance = new PoolsApi();
        Pool pool = ; // Pool | This object represents all the TidalPool settings that can be set at TidalPool creation

        try {
            inline_response_200 result = apiInstance.createPool(pool);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PoolsApi#createPool");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.PoolsApi;

public class PoolsApiExample {

    public static void main(String[] args) {
        PoolsApi apiInstance = new PoolsApi();
        Pool pool = ; // Pool | This object represents all the TidalPool settings that can be set at TidalPool creation

        try {
            inline_response_200 result = apiInstance.createPool(pool);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PoolsApi#createPool");
            e.printStackTrace();
        }
    }
}
Pool *pool = ; // This object represents all the TidalPool settings that can be set at TidalPool creation


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

// Create a new TidalPool
[apiInstance createPoolWith:pool
              completionHandler: ^(inline_response_200 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WaveRunnerApi = require('wave_runner_api');

var api = new WaveRunnerApi.PoolsApi()

var pool = ; // {Pool} This object represents all the TidalPool settings that can be set at TidalPool creation



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

namespace Example
{
    public class createPoolExample
    {
        public void main()
        {
            
            var apiInstance = new PoolsApi();
            var pool = new Pool(); // Pool | This object represents all the TidalPool settings that can be set at TidalPool creation


            try
            {
                // Create a new TidalPool
                inline_response_200 result = apiInstance.createPool(pool);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PoolsApi.createPool: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\PoolsApi();
$pool = ; // Pool | This object represents all the TidalPool settings that can be set at TidalPool creation


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

my $api_instance = WWW::SwaggerClient::PoolsApi->new();
my $pool = WWW::SwaggerClient::Object::Pool->new(); # Pool | This object represents all the TidalPool settings that can be set at TidalPool creation


eval { 
    my $result = $api_instance->createPool(pool => $pool);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PoolsApi->createPool: $@\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.PoolsApi()
pool =  # Pool | This object represents all the TidalPool settings that can be set at TidalPool creation


try: 
    # Create a new TidalPool
    api_response = api_instance.create_pool(pool)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PoolsApi->createPool: %s\n" % e)

Parameters

Body parameters
Name Description
pool *

Responses

Status: 201 - TidalPool Created

Status: 500 - Internal Server Error


getPools

List TidalPools available to the authenticated user

This method assumes that the user has authenticated into an Admin context [TBD] and returns the TidalPools they are entitled to view.


/pools

Usage and SDK Samples

curl -X GET "https://api.tidalscale.com/v1/pools"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PoolsApi;

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

public class PoolsApiExample {

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

public class PoolsApiExample {

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

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

// List TidalPools available to the authenticated user
[apiInstance getPoolsWithCompletionHandler: 
              ^(array[inline_response_200] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WaveRunnerApi = require('wave_runner_api');

var api = new WaveRunnerApi.PoolsApi()

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

namespace Example
{
    public class getPoolsExample
    {
        public void main()
        {
            
            var apiInstance = new PoolsApi();

            try
            {
                // List TidalPools available to the authenticated user
                array[inline_response_200] result = apiInstance.getPools();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PoolsApi.getPools: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

try: 
    # List TidalPools available to the authenticated user
    api_response = api_instance.get_pools()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PoolsApi->getPools: %s\n" % e)

Parameters

Responses

Status: 200 - OK

Status: 500 - Internal Server Error


getSwitch

Return a specific Switch in a TidalPool


/pools/{poolId}/switches/{switchId}

Usage and SDK Samples

curl -X GET "https://api.tidalscale.com/v1/pools/{poolId}/switches/{switchId}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PoolsApi;

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

public class PoolsApiExample {

    public static void main(String[] args) {
        
        PoolsApi apiInstance = new PoolsApi();
        String poolId = poolId_example; // String | The ID of the desired TidalPool containing these Switches
        String switchId = switchId_example; // String | The ID of the desired Switch
        try {
            inline_response_200_2 result = apiInstance.getSwitch(poolId, switchId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PoolsApi#getSwitch");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.PoolsApi;

public class PoolsApiExample {

    public static void main(String[] args) {
        PoolsApi apiInstance = new PoolsApi();
        String poolId = poolId_example; // String | The ID of the desired TidalPool containing these Switches
        String switchId = switchId_example; // String | The ID of the desired Switch
        try {
            inline_response_200_2 result = apiInstance.getSwitch(poolId, switchId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PoolsApi#getSwitch");
            e.printStackTrace();
        }
    }
}
String *poolId = poolId_example; // The ID of the desired TidalPool containing these Switches
String *switchId = switchId_example; // The ID of the desired Switch

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

// Return a specific Switch in a TidalPool
[apiInstance getSwitchWith:poolId
    switchId:switchId
              completionHandler: ^(inline_response_200_2 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WaveRunnerApi = require('wave_runner_api');

var api = new WaveRunnerApi.PoolsApi()

var poolId = poolId_example; // {String} The ID of the desired TidalPool containing these Switches

var switchId = switchId_example; // {String} The ID of the desired Switch


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

namespace Example
{
    public class getSwitchExample
    {
        public void main()
        {
            
            var apiInstance = new PoolsApi();
            var poolId = poolId_example;  // String | The ID of the desired TidalPool containing these Switches
            var switchId = switchId_example;  // String | The ID of the desired Switch

            try
            {
                // Return a specific Switch in a TidalPool
                inline_response_200_2 result = apiInstance.getSwitch(poolId, switchId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PoolsApi.getSwitch: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\PoolsApi();
$poolId = poolId_example; // String | The ID of the desired TidalPool containing these Switches
$switchId = switchId_example; // String | The ID of the desired Switch

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

my $api_instance = WWW::SwaggerClient::PoolsApi->new();
my $poolId = poolId_example; # String | The ID of the desired TidalPool containing these Switches
my $switchId = switchId_example; # String | The ID of the desired Switch

eval { 
    my $result = $api_instance->getSwitch(poolId => $poolId, switchId => $switchId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PoolsApi->getSwitch: $@\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.PoolsApi()
poolId = poolId_example # String | The ID of the desired TidalPool containing these Switches
switchId = switchId_example # String | The ID of the desired Switch

try: 
    # Return a specific Switch in a TidalPool
    api_response = api_instance.get_switch(poolId, switchId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PoolsApi->getSwitch: %s\n" % e)

Parameters

Path parameters
Name Description
poolId*
String
The ID of the desired TidalPool containing these Switches
Required
switchId*
String
The ID of the desired Switch
Required

Responses

Status: 200 - OK

Status: 404 - No Switch found with that ID

Status: 500 - Internal Server Error


getSwitches

List the Switches in the specified TidalPool


/pools/{poolId}/switches

Usage and SDK Samples

curl -X GET "https://api.tidalscale.com/v1/pools/{poolId}/switches"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PoolsApi;

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

public class PoolsApiExample {

    public static void main(String[] args) {
        
        PoolsApi apiInstance = new PoolsApi();
        String poolId = poolId_example; // String | The ID of the desired TidalPool containing these Switches
        try {
            array[inline_response_200_2] result = apiInstance.getSwitches(poolId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PoolsApi#getSwitches");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.PoolsApi;

public class PoolsApiExample {

    public static void main(String[] args) {
        PoolsApi apiInstance = new PoolsApi();
        String poolId = poolId_example; // String | The ID of the desired TidalPool containing these Switches
        try {
            array[inline_response_200_2] result = apiInstance.getSwitches(poolId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PoolsApi#getSwitches");
            e.printStackTrace();
        }
    }
}
String *poolId = poolId_example; // The ID of the desired TidalPool containing these Switches

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

// List the Switches in the specified TidalPool
[apiInstance getSwitchesWith:poolId
              completionHandler: ^(array[inline_response_200_2] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WaveRunnerApi = require('wave_runner_api');

var api = new WaveRunnerApi.PoolsApi()

var poolId = poolId_example; // {String} The ID of the desired TidalPool containing these Switches


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

namespace Example
{
    public class getSwitchesExample
    {
        public void main()
        {
            
            var apiInstance = new PoolsApi();
            var poolId = poolId_example;  // String | The ID of the desired TidalPool containing these Switches

            try
            {
                // List the Switches in the specified TidalPool
                array[inline_response_200_2] result = apiInstance.getSwitches(poolId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PoolsApi.getSwitches: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\PoolsApi();
$poolId = poolId_example; // String | The ID of the desired TidalPool containing these Switches

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

my $api_instance = WWW::SwaggerClient::PoolsApi->new();
my $poolId = poolId_example; # String | The ID of the desired TidalPool containing these Switches

eval { 
    my $result = $api_instance->getSwitches(poolId => $poolId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PoolsApi->getSwitches: $@\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.PoolsApi()
poolId = poolId_example # String | The ID of the desired TidalPool containing these Switches

try: 
    # List the Switches in the specified TidalPool
    api_response = api_instance.get_switches(poolId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PoolsApi->getSwitches: %s\n" % e)

Parameters

Path parameters
Name Description
poolId*
String
The ID of the desired TidalPool containing these Switches
Required

Responses

Status: 200 - OK

Status: 404 - No Switches in this TidalPool

Status: 500 - Internal Server Error


Ssh

getGuestShellWebSocket

WebSocket to connect to guest shell

Streams the websocket to a new guest shell connection. The username may be specified with the optional "user@" prefix to guestshell


/pools/{poolId}/pods/{podId}/ws/<user@>guestshell

Usage and SDK Samples

curl -X GET "https://api.tidalscale.com/v1/pools/{poolId}/pods/{podId}/ws/<user@>guestshell"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SshApi;

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

public class SshApiExample {

    public static void main(String[] args) {
        
        SshApi apiInstance = new SshApi();
        String poolId = poolId_example; // String | The ID of the desired TidalPool containing this TidalPod
        String podId = podId_example; // String | The ID of the desired TidalPod to connect to guest shell
        try {
            apiInstance.getGuestShellWebSocket(poolId, podId);
        } catch (ApiException e) {
            System.err.println("Exception when calling SshApi#getGuestShellWebSocket");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.SshApi;

public class SshApiExample {

    public static void main(String[] args) {
        SshApi apiInstance = new SshApi();
        String poolId = poolId_example; // String | The ID of the desired TidalPool containing this TidalPod
        String podId = podId_example; // String | The ID of the desired TidalPod to connect to guest shell
        try {
            apiInstance.getGuestShellWebSocket(poolId, podId);
        } catch (ApiException e) {
            System.err.println("Exception when calling SshApi#getGuestShellWebSocket");
            e.printStackTrace();
        }
    }
}
String *poolId = poolId_example; // The ID of the desired TidalPool containing this TidalPod
String *podId = podId_example; // The ID of the desired TidalPod to connect to guest shell

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

// WebSocket to connect to guest shell
[apiInstance getGuestShellWebSocketWith:poolId
    podId:podId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WaveRunnerApi = require('wave_runner_api');

var api = new WaveRunnerApi.SshApi()

var poolId = poolId_example; // {String} The ID of the desired TidalPool containing this TidalPod

var podId = podId_example; // {String} The ID of the desired TidalPod to connect to guest shell


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

namespace Example
{
    public class getGuestShellWebSocketExample
    {
        public void main()
        {
            
            var apiInstance = new SshApi();
            var poolId = poolId_example;  // String | The ID of the desired TidalPool containing this TidalPod
            var podId = podId_example;  // String | The ID of the desired TidalPod to connect to guest shell

            try
            {
                // WebSocket to connect to guest shell
                apiInstance.getGuestShellWebSocket(poolId, podId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SshApi.getGuestShellWebSocket: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\SshApi();
$poolId = poolId_example; // String | The ID of the desired TidalPool containing this TidalPod
$podId = podId_example; // String | The ID of the desired TidalPod to connect to guest shell

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

my $api_instance = WWW::SwaggerClient::SshApi->new();
my $poolId = poolId_example; # String | The ID of the desired TidalPool containing this TidalPod
my $podId = podId_example; # String | The ID of the desired TidalPod to connect to guest shell

eval {