Skip to content

Openstack

Operations Summary

Method Endpoint Description
GET /api/openstack/discovery/ List Openstack Discovery
GET /api/openstack/discovery/{id}/ Retrieve
GET /api/openstack-health-monitors/ List health monitors
GET /api/openstack-health-monitors/{uuid}/ Get health monitor details
GET /api/openstack-hypervisor-inventories/ List Openstack Hypervisor Inventories
GET /api/openstack-hypervisor-inventories/{uuid}/ Retrieve
GET /api/openstack-hypervisors/allocation_candidates/ Pre-flight allocation candidates
GET /api/openstack-hypervisors/ List Openstack Hypervisors
GET /api/openstack-hypervisors/{uuid}/ Retrieve
GET /api/openstack-hypervisors/summary/ Get hypervisor summary statistics
GET /api/openstack-listeners/ List listeners
GET /api/openstack-listeners/{uuid}/ Get listener details
GET /api/openstack-loadbalancers/ List load balancers
GET /api/openstack-loadbalancers/{uuid}/ Get load balancer details
GET /api/openstack-pool-members/ List pool members
GET /api/openstack-pool-members/{uuid}/ Get pool member details
GET /api/openstack-pools/ List pools
GET /api/openstack-pools/{uuid}/ Get pool details
POST /api/openstack/discovery/ Create
POST /api/openstack/discovery/discover_external_networks/ Discover available external networks
POST /api/openstack/discovery/discover_flavors/ Discover available flavors
POST /api/openstack/discovery/discover_instance_availability_zones/ Discover available Nova instance availability zones
POST /api/openstack/discovery/discover_volume_availability_zones/ Discover available Cinder volume availability zones
POST /api/openstack/discovery/discover_volume_types/ Discover available volume types
POST /api/openstack/discovery/preview_service_attributes/ Build service_attributes and plugin_options from selected values
POST /api/openstack/discovery/validate_credentials/ Validate OpenStack credentials without saving them
POST /api/openstack-health-monitors/ Create health monitor
POST /api/openstack-health-monitors/{uuid}/pull/ Pull health monitor
POST /api/openstack-listeners/ Create listener
POST /api/openstack-listeners/{uuid}/pull/ Pull listener
POST /api/openstack-loadbalancers/{uuid}/attach_floating_ip/ Attach floating IP to VIP
POST /api/openstack-loadbalancers/ Create load balancer
POST /api/openstack-loadbalancers/{uuid}/detach_floating_ip/ Detach floating IP from VIP
POST /api/openstack-loadbalancers/{uuid}/pull/ Pull load balancer
POST /api/openstack-loadbalancers/{uuid}/set_security_groups/ Set security groups on VIP port
POST /api/openstack-loadbalancers/{uuid}/unlink/ Unlink load balancer
POST /api/openstack-pool-members/ Create pool member
POST /api/openstack-pool-members/{uuid}/pull/ Pull pool member
POST /api/openstack-pools/ Create pool
POST /api/openstack-pools/{uuid}/pull/ Pull pool
PUT /api/openstack/discovery/{id}/ Update
PUT /api/openstack-health-monitors/{uuid}/ Update health monitor
PUT /api/openstack-listeners/{uuid}/ Update listener
PUT /api/openstack-loadbalancers/{uuid}/ Update load balancer
PUT /api/openstack-pool-members/{uuid}/ Update pool member
PUT /api/openstack-pools/{uuid}/ Update pool
PATCH /api/openstack/discovery/{id}/ Partial Update
PATCH /api/openstack-health-monitors/{uuid}/ Partially update health monitor
PATCH /api/openstack-listeners/{uuid}/ Partially update listener
PATCH /api/openstack-loadbalancers/{uuid}/ Partially update load balancer
PATCH /api/openstack-pool-members/{uuid}/ Partially update pool member
PATCH /api/openstack-pools/{uuid}/ Partially update pool
DELETE /api/openstack/discovery/{id}/ Delete
DELETE /api/openstack-health-monitors/{uuid}/ Delete health monitor
DELETE /api/openstack-listeners/{uuid}/ Delete listener
DELETE /api/openstack-loadbalancers/{uuid}/ Delete load balancer
DELETE /api/openstack-pool-members/{uuid}/ Delete pool member
DELETE /api/openstack-pools/{uuid}/ Delete pool

List Openstack Discovery

1
2
3
4
http \
  GET \
  https://api.example.com/api/openstack/discovery/ \
  Authorization:"Token YOUR_API_TOKEN"

1
2
3
4
5
6
7
8
9
from waldur_api_client.client import AuthenticatedClient
from waldur_api_client.api.openstack import openstack_discovery_list # (1)

client = AuthenticatedClient(
    base_url="https://api.example.com", token="YOUR_API_TOKEN"
)
response = openstack_discovery_list.sync(client=client)

print(response)
  1. API Source: openstack_discovery_list
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
import { openstackDiscoveryList } from 'waldur-js-client';

try {
  const response = await openstackDiscoveryList({
  auth: "Token YOUR_API_TOKEN"
});
  console.log('Success:', response);
} catch (error) {
  console.error('Error:', error);
}
Name Type Description
page integer A page number within the paginated result set.
page_size integer Number of results to return per page.

200 - No response body

Retrieve

1
2
3
4
http \
  GET \
  https://api.example.com/api/openstack/discovery/123/ \
  Authorization:"Token YOUR_API_TOKEN"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
from waldur_api_client.client import AuthenticatedClient
from waldur_api_client.api.openstack import openstack_discovery_retrieve # (1)

client = AuthenticatedClient(
    base_url="https://api.example.com", token="YOUR_API_TOKEN"
)
response = openstack_discovery_retrieve.sync(
    id=123,
    client=client
)

print(response)
  1. API Source: openstack_discovery_retrieve
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import { openstackDiscoveryRetrieve } from 'waldur-js-client';

try {
  const response = await openstackDiscoveryRetrieve({
  auth: "Token YOUR_API_TOKEN",
  path: {
    "id": 123
  }
});
  console.log('Success:', response);
} catch (error) {
  console.error('Error:', error);
}
Name Type Required Description
id integer ✓ A unique integer value identifying this Service provider.

200 - No response body

List health monitors

Get a list of pool health monitors.

1
2
3
4
http \
  GET \
  https://api.example.com/api/openstack-health-monitors/ \
  Authorization:"Token YOUR_API_TOKEN"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
from waldur_api_client.client import AuthenticatedClient
from waldur_api_client.models.core_states import CoreStates # (1)
from waldur_api_client.models.open_stack_health_monitor_field_enum import OpenStackHealthMonitorFieldEnum # (2)
from waldur_api_client.api.openstack_health_monitors import openstack_health_monitors_list # (3)

client = AuthenticatedClient(
    base_url="https://api.example.com", token="YOUR_API_TOKEN"
)
response = openstack_health_monitors_list.sync(client=client)

for item in response:
    print(item)
  1. Model Source: CoreStates
  2. Model Source: OpenStackHealthMonitorFieldEnum
  3. API Source: openstack_health_monitors_list
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
import { openstackHealthMonitorsList } from 'waldur-js-client';

try {
  const response = await openstackHealthMonitorsList({
  auth: "Token YOUR_API_TOKEN"
});
  console.log('Success:', response);
} catch (error) {
  console.error('Error:', error);
}
Name Type Description
field array
load_balancer_uuid string (uuid) Load balancer UUID
name string Name
name_exact string Name (exact)
page integer A page number within the paginated result set.
page_size integer Number of results to return per page.
pool string (uri) Pool URL
pool_uuid string (uuid) Pool UUID
state array State
tenant_uuid string (uuid) Tenant UUID

200 -

The response body is an array of objects, where each object has the following structure:

Field Type Description
url string (uri)
uuid string (uuid)
name string
description string
service_name string
service_settings string (uri)
service_settings_uuid string (uuid)
service_settings_state string
service_settings_error_message string
project string (uri)
project_name string
project_uuid string (uuid)
customer string (uri)
customer_uuid string (uuid)
customer_name string
customer_native_name string
customer_abbreviation string
error_message string
error_traceback string
resource_type string
state any
created string (date-time)
modified string (date-time)
backend_id string Health monitor ID in Octavia
access_url any
pool string (uri) Pool this health monitor belongs to
pool_name string
pool_uuid string (uuid)
load_balancer_uuid string (uuid)
type string
delay integer
timeout integer
max_retries integer
provisioning_status string
operating_status string
marketplace_offering_uuid string
marketplace_offering_name string
marketplace_offering_type string
marketplace_offering_plugin_options object (free-form)
marketplace_category_uuid string
marketplace_category_name string
marketplace_resource_uuid string
marketplace_plan_uuid string
marketplace_resource_state string
is_usage_based boolean
is_limit_based boolean

Get health monitor details

Retrieve details of a specific health monitor.

1
2
3
4
http \
  GET \
  https://api.example.com/api/openstack-health-monitors/a1b2c3d4-e5f6-7890-abcd-ef1234567890/ \
  Authorization:"Token YOUR_API_TOKEN"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
from waldur_api_client.client import AuthenticatedClient
from waldur_api_client.models.open_stack_health_monitor_field_enum import OpenStackHealthMonitorFieldEnum # (1)
from waldur_api_client.api.openstack_health_monitors import openstack_health_monitors_retrieve # (2)

client = AuthenticatedClient(
    base_url="https://api.example.com", token="YOUR_API_TOKEN"
)
response = openstack_health_monitors_retrieve.sync(
    uuid="a1b2c3d4-e5f6-7890-abcd-ef1234567890",
    client=client
)

print(response)
  1. Model Source: OpenStackHealthMonitorFieldEnum
  2. API Source: openstack_health_monitors_retrieve
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import { openstackHealthMonitorsRetrieve } from 'waldur-js-client';

try {
  const response = await openstackHealthMonitorsRetrieve({
  auth: "Token YOUR_API_TOKEN",
  path: {
    "uuid": "a1b2c3d4-e5f6-7890-abcd-ef1234567890"
  }
});
  console.log('Success:', response);
} catch (error) {
  console.error('Error:', error);
}
Name Type Required
uuid string (uuid) ✓
Name Type
field array

200 -

Field Type Description
url string (uri)
uuid string (uuid)
name string
description string
service_name string
service_settings string (uri)
service_settings_uuid string (uuid)
service_settings_state string
service_settings_error_message string
project string (uri)
project_name string
project_uuid string (uuid)
customer string (uri)
customer_uuid string (uuid)
customer_name string
customer_native_name string
customer_abbreviation string
error_message string
error_traceback string
resource_type string
state any
created string (date-time)
modified string (date-time)
backend_id string Health monitor ID in Octavia
access_url any
pool string (uri) Pool this health monitor belongs to
pool_name string
pool_uuid string (uuid)
load_balancer_uuid string (uuid)
type string
delay integer
timeout integer
max_retries integer
provisioning_status string
operating_status string
marketplace_offering_uuid string
marketplace_offering_name string
marketplace_offering_type string
marketplace_offering_plugin_options object (free-form)
marketplace_category_uuid string
marketplace_category_name string
marketplace_resource_uuid string
marketplace_plan_uuid string
marketplace_resource_state string
is_usage_based boolean
is_limit_based boolean

List Openstack Hypervisor Inventories

1
2
3
4
http \
  GET \
  https://api.example.com/api/openstack-hypervisor-inventories/ \
  Authorization:"Token YOUR_API_TOKEN"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
from waldur_api_client.client import AuthenticatedClient
from waldur_api_client.api.openstack_hypervisor_inventories import openstack_hypervisor_inventories_list # (1)

client = AuthenticatedClient(
    base_url="https://api.example.com", token="YOUR_API_TOKEN"
)
response = openstack_hypervisor_inventories_list.sync(client=client)

for item in response:
    print(item)
  1. API Source: openstack_hypervisor_inventories_list
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
import { openstackHypervisorInventoriesList } from 'waldur-js-client';

try {
  const response = await openstackHypervisorInventoriesList({
  auth: "Token YOUR_API_TOKEN"
});
  console.log('Success:', response);
} catch (error) {
  console.error('Error:', error);
}
Name Type Description
hypervisor_uuid string (uuid)
page integer A page number within the paginated result set.
page_size integer Number of results to return per page.
resource_class string
settings_uuid string (uuid)

200 -

The response body is an array of objects, where each object has the following structure:

Field Type Description
url string (uri)
uuid string (uuid)
hypervisor string (uri)
hypervisor_uuid string (uuid)
hypervisor_name string
settings string (uri)
settings_uuid string (uuid)
resource_class string Placement resource class, e.g. VCPU, MEMORY_MB, DISK_GB, VGPU, PCI_DEVICE, NUMA_CORE, CUSTOM_*.
total integer (int64)
reserved integer (int64)
allocation_ratio number (double)
used integer (int64)
effective_total integer Capacity the Nova scheduler treats as available.

Retrieve

1
2
3
4
http \
  GET \
  https://api.example.com/api/openstack-hypervisor-inventories/a1b2c3d4-e5f6-7890-abcd-ef1234567890/ \
  Authorization:"Token YOUR_API_TOKEN"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
from waldur_api_client.client import AuthenticatedClient
from waldur_api_client.api.openstack_hypervisor_inventories import openstack_hypervisor_inventories_retrieve # (1)

client = AuthenticatedClient(
    base_url="https://api.example.com", token="YOUR_API_TOKEN"
)
response = openstack_hypervisor_inventories_retrieve.sync(
    uuid="a1b2c3d4-e5f6-7890-abcd-ef1234567890",
    client=client
)

print(response)
  1. API Source: openstack_hypervisor_inventories_retrieve
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import { openstackHypervisorInventoriesRetrieve } from 'waldur-js-client';

try {
  const response = await openstackHypervisorInventoriesRetrieve({
  auth: "Token YOUR_API_TOKEN",
  path: {
    "uuid": "a1b2c3d4-e5f6-7890-abcd-ef1234567890"
  }
});
  console.log('Success:', response);
} catch (error) {
  console.error('Error:', error);
}
Name Type Required
uuid string (uuid) ✓

200 -

Field Type Description
url string (uri)
uuid string (uuid)
hypervisor string (uri)
hypervisor_uuid string (uuid)
hypervisor_name string
settings string (uri)
settings_uuid string (uuid)
resource_class string Placement resource class, e.g. VCPU, MEMORY_MB, DISK_GB, VGPU, PCI_DEVICE, NUMA_CORE, CUSTOM_*.
total integer (int64)
reserved integer (int64)
allocation_ratio number (double)
used integer (int64)
effective_total integer Capacity the Nova scheduler treats as available.

Pre-flight allocation candidates

Ask Placement which compute hosts could currently satisfy a request for the given resources (and required traits). Useful as a pre-flight check before placing an order on a fully-booked cloud. Returns 0 candidates when nothing fits, with the same provider_summaries Placement returns for diagnostic display.

1
2
3
4
5
6
http \
  GET \
  https://api.example.com/api/openstack-hypervisors/allocation_candidates/ \
  Authorization:"Token YOUR_API_TOKEN" \
  resources=="string-value" \
  settings_uuid=="a1b2c3d4-e5f6-7890-abcd-ef1234567890"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
from waldur_api_client.client import AuthenticatedClient
from waldur_api_client.api.openstack_hypervisors import openstack_hypervisors_allocation_candidates_retrieve # (1)

client = AuthenticatedClient(
    base_url="https://api.example.com", token="YOUR_API_TOKEN"
)
response = openstack_hypervisors_allocation_candidates_retrieve.sync(
    client=client,
    resources="string-value",
    settings_uuid="a1b2c3d4-e5f6-7890-abcd-ef1234567890"
)

print(response)
  1. API Source: openstack_hypervisors_allocation_candidates_retrieve
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
import { openstackHypervisorsAllocationCandidatesRetrieve } from 'waldur-js-client';

try {
  const response = await openstackHypervisorsAllocationCandidatesRetrieve({
  auth: "Token YOUR_API_TOKEN",
  query: {
    "resources": "string-value",
    "settings_uuid": "a1b2c3d4-e5f6-7890-abcd-ef1234567890"
  }
});
  console.log('Success:', response);
} catch (error) {
  console.error('Error:', error);
}
Name Type Required Description
limit integer Cap on returned candidates (default 10).
required string e.g. HW_CPU_X86_AVX2,STORAGE_DISK_SSD
resources string ✓ e.g. VCPU:4,MEMORY_MB:8192,DISK_GB:10
settings_uuid string (uuid) ✓

200 -

Field Type Description
candidate_count integer Total number of allocation candidates Placement returned.
provider_summaries object (free-form) Placement's per-provider summary: maps resource_provider_uuid → {resources: {CLASS: {used, capacity}, ...}, traits: [...]}.

List Openstack Hypervisors

1
2
3
4
http \
  GET \
  https://api.example.com/api/openstack-hypervisors/ \
  Authorization:"Token YOUR_API_TOKEN"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
from waldur_api_client.client import AuthenticatedClient
from waldur_api_client.api.openstack_hypervisors import openstack_hypervisors_list # (1)

client = AuthenticatedClient(
    base_url="https://api.example.com", token="YOUR_API_TOKEN"
)
response = openstack_hypervisors_list.sync(client=client)

for item in response:
    print(item)
  1. API Source: openstack_hypervisors_list
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
import { openstackHypervisorsList } from 'waldur-js-client';

try {
  const response = await openstackHypervisorsList({
  auth: "Token YOUR_API_TOKEN"
});
  console.log('Success:', response);
} catch (error) {
  console.error('Error:', error);
}
Name Type Description
hypervisor_type string
name string Name
name_exact string Name (exact)
page integer A page number within the paginated result set.
page_size integer Number of results to return per page.
settings string (uri) Settings URL
settings_uuid string (uuid) Settings UUID
state string
status string
trait string Trait names with AND logic (comma-separated)

200 -

The response body is an array of objects, where each object has the following structure:

Field Type Description
url string (uri)
uuid string (uuid)
name string
settings string (uri)
backend_id string
hypervisor_type string Hypervisor type, e.g. KVM, QEMU, VMware
vcpus integer Total vCPUs
vcpus_used integer Used vCPUs
memory_mb integer Total RAM in MiB
memory_mb_used integer Used RAM in MiB
local_gb integer Total disk in GiB
local_gb_used integer Used disk in GiB
running_vms integer Number of running VMs
state string Hypervisor state, e.g. up or down
status string Hypervisor status, e.g. enabled or disabled
traits array of strings

Retrieve

1
2
3
4
http \
  GET \
  https://api.example.com/api/openstack-hypervisors/a1b2c3d4-e5f6-7890-abcd-ef1234567890/ \
  Authorization:"Token YOUR_API_TOKEN"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
from waldur_api_client.client import AuthenticatedClient
from waldur_api_client.api.openstack_hypervisors import openstack_hypervisors_retrieve # (1)

client = AuthenticatedClient(
    base_url="https://api.example.com", token="YOUR_API_TOKEN"
)
response = openstack_hypervisors_retrieve.sync(
    uuid="a1b2c3d4-e5f6-7890-abcd-ef1234567890",
    client=client
)

print(response)
  1. API Source: openstack_hypervisors_retrieve
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import { openstackHypervisorsRetrieve } from 'waldur-js-client';

try {
  const response = await openstackHypervisorsRetrieve({
  auth: "Token YOUR_API_TOKEN",
  path: {
    "uuid": "a1b2c3d4-e5f6-7890-abcd-ef1234567890"
  }
});
  console.log('Success:', response);
} catch (error) {
  console.error('Error:', error);
}
Name Type Required
uuid string (uuid) ✓

200 -

Field Type Description
url string (uri)
uuid string (uuid)
name string
settings string (uri)
backend_id string
hypervisor_type string Hypervisor type, e.g. KVM, QEMU, VMware
vcpus integer Total vCPUs
vcpus_used integer Used vCPUs
memory_mb integer Total RAM in MiB
memory_mb_used integer Used RAM in MiB
local_gb integer Total disk in GiB
local_gb_used integer Used disk in GiB
running_vms integer Number of running VMs
state string Hypervisor state, e.g. up or down
status string Hypervisor status, e.g. enabled or disabled
traits array of strings

Get hypervisor summary statistics

Return aggregated vCPU, RAM and disk totals across all hypervisors matching the current filter (e.g. settings_uuid).

1
2
3
4
5
http \
  GET \
  https://api.example.com/api/openstack-hypervisors/summary/ \
  Authorization:"Token YOUR_API_TOKEN" \
  settings_uuid=="a1b2c3d4-e5f6-7890-abcd-ef1234567890"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
from waldur_api_client.client import AuthenticatedClient
from waldur_api_client.api.openstack_hypervisors import openstack_hypervisors_summary_retrieve # (1)

client = AuthenticatedClient(
    base_url="https://api.example.com", token="YOUR_API_TOKEN"
)
response = openstack_hypervisors_summary_retrieve.sync(
    client=client,
    settings_uuid="a1b2c3d4-e5f6-7890-abcd-ef1234567890"
)

print(response)
  1. API Source: openstack_hypervisors_summary_retrieve
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import { openstackHypervisorsSummaryRetrieve } from 'waldur-js-client';

try {
  const response = await openstackHypervisorsSummaryRetrieve({
  auth: "Token YOUR_API_TOKEN",
  query: {
    "settings_uuid": "a1b2c3d4-e5f6-7890-abcd-ef1234567890"
  }
});
  console.log('Success:', response);
} catch (error) {
  console.error('Error:', error);
}
Name Type Required Description
settings_uuid string (uuid) ✓ UUID of the OpenStack ServiceSettings to aggregate over.

200 -

Field Type
total_vcpus integer
used_vcpus integer
total_memory_mb integer
used_memory_mb integer
total_local_gb integer
used_local_gb integer
total_running_vms integer

List listeners

Get a list of load balancer listeners.

1
2
3
4
http \
  GET \
  https://api.example.com/api/openstack-listeners/ \
  Authorization:"Token YOUR_API_TOKEN"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
from waldur_api_client.client import AuthenticatedClient
from waldur_api_client.models.core_states import CoreStates # (1)
from waldur_api_client.models.open_stack_listener_field_enum import OpenStackListenerFieldEnum # (2)
from waldur_api_client.api.openstack_listeners import openstack_listeners_list # (3)

client = AuthenticatedClient(
    base_url="https://api.example.com", token="YOUR_API_TOKEN"
)
response = openstack_listeners_list.sync(client=client)

for item in response:
    print(item)
  1. Model Source: CoreStates
  2. Model Source: OpenStackListenerFieldEnum
  3. API Source: openstack_listeners_list
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
import { openstackListenersList } from 'waldur-js-client';

try {
  const response = await openstackListenersList({
  auth: "Token YOUR_API_TOKEN"
});
  console.log('Success:', response);
} catch (error) {
  console.error('Error:', error);
}
Name Type Description
field array
load_balancer string (uri) Load balancer URL
load_balancer_uuid string (uuid) Load balancer UUID
name string Name
name_exact string Name (exact)
page integer A page number within the paginated result set.
page_size integer Number of results to return per page.
state array State
tenant_uuid string (uuid) Tenant UUID

200 -

The response body is an array of objects, where each object has the following structure:

Field Type Description
url string (uri)
uuid string (uuid)
name string
description string
service_name string
service_settings string (uri)
service_settings_uuid string (uuid)
service_settings_state string
service_settings_error_message string
project string (uri)
project_name string
project_uuid string (uuid)
customer string (uri)
customer_uuid string (uuid)
customer_name string
customer_native_name string
customer_abbreviation string
error_message string
error_traceback string
resource_type string
state any
created string (date-time)
modified string (date-time)
backend_id string Listener ID in Octavia
access_url any
load_balancer string (uri) Load balancer this listener belongs to
load_balancer_name string
load_balancer_uuid string (uuid)
protocol string
protocol_port integer
default_pool string (uri) Default pool for this listener
provisioning_status string
operating_status string
marketplace_offering_uuid string
marketplace_offering_name string
marketplace_offering_type string
marketplace_offering_plugin_options object (free-form)
marketplace_category_uuid string
marketplace_category_name string
marketplace_resource_uuid string
marketplace_plan_uuid string
marketplace_resource_state string
is_usage_based boolean
is_limit_based boolean

Get listener details

Retrieve details of a specific listener.

1
2
3
4
http \
  GET \
  https://api.example.com/api/openstack-listeners/a1b2c3d4-e5f6-7890-abcd-ef1234567890/ \
  Authorization:"Token YOUR_API_TOKEN"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
from waldur_api_client.client import AuthenticatedClient
from waldur_api_client.models.open_stack_listener_field_enum import OpenStackListenerFieldEnum # (1)
from waldur_api_client.api.openstack_listeners import openstack_listeners_retrieve # (2)

client = AuthenticatedClient(
    base_url="https://api.example.com", token="YOUR_API_TOKEN"
)
response = openstack_listeners_retrieve.sync(
    uuid="a1b2c3d4-e5f6-7890-abcd-ef1234567890",
    client=client
)

print(response)
  1. Model Source: OpenStackListenerFieldEnum
  2. API Source: openstack_listeners_retrieve
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import { openstackListenersRetrieve } from 'waldur-js-client';

try {
  const response = await openstackListenersRetrieve({
  auth: "Token YOUR_API_TOKEN",
  path: {
    "uuid": "a1b2c3d4-e5f6-7890-abcd-ef1234567890"
  }
});
  console.log('Success:', response);
} catch (error) {
  console.error('Error:', error);
}
Name Type Required
uuid string (uuid) ✓
Name Type
field array

200 -

Field Type Description
url string (uri)
uuid string (uuid)
name string
description string
service_name string
service_settings string (uri)
service_settings_uuid string (uuid)
service_settings_state string
service_settings_error_message string
project string (uri)
project_name string
project_uuid string (uuid)
customer string (uri)
customer_uuid string (uuid)
customer_name string
customer_native_name string
customer_abbreviation string
error_message string
error_traceback string
resource_type string
state any
created string (date-time)
modified string (date-time)
backend_id string Listener ID in Octavia
access_url any
load_balancer string (uri) Load balancer this listener belongs to
load_balancer_name string
load_balancer_uuid string (uuid)
protocol string
protocol_port integer
default_pool string (uri) Default pool for this listener
provisioning_status string
operating_status string
marketplace_offering_uuid string
marketplace_offering_name string
marketplace_offering_type string
marketplace_offering_plugin_options object (free-form)
marketplace_category_uuid string
marketplace_category_name string
marketplace_resource_uuid string
marketplace_plan_uuid string
marketplace_resource_state string
is_usage_based boolean
is_limit_based boolean

List load balancers

Get a list of load balancers.

1
2
3
4
http \
  GET \
  https://api.example.com/api/openstack-loadbalancers/ \
  Authorization:"Token YOUR_API_TOKEN"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
from waldur_api_client.client import AuthenticatedClient
from waldur_api_client.models.core_states import CoreStates # (1)
from waldur_api_client.models.open_stack_load_balancer_field_enum import OpenStackLoadBalancerFieldEnum # (2)
from waldur_api_client.api.openstack_loadbalancers import openstack_loadbalancers_list # (3)

client = AuthenticatedClient(
    base_url="https://api.example.com", token="YOUR_API_TOKEN"
)
response = openstack_loadbalancers_list.sync(client=client)

for item in response:
    print(item)
  1. Model Source: CoreStates
  2. Model Source: OpenStackLoadBalancerFieldEnum
  3. API Source: openstack_loadbalancers_list
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
import { openstackLoadbalancersList } from 'waldur-js-client';

try {
  const response = await openstackLoadbalancersList({
  auth: "Token YOUR_API_TOKEN"
});
  console.log('Success:', response);
} catch (error) {
  console.error('Error:', error);
}
Name Type Description
field array
name string Name
name_exact string Name (exact)
page integer A page number within the paginated result set.
page_size integer Number of results to return per page.
state array State
tenant string (uri) Tenant URL
tenant_uuid string (uuid) Tenant UUID

200 -

The response body is an array of objects, where each object has the following structure:

Field Type Description
url string (uri)
uuid string (uuid)
name string
description string
service_name string
service_settings string (uri)
service_settings_uuid string (uuid)
service_settings_state string
service_settings_error_message string
project string (uri)
project_name string
project_uuid string (uuid)
customer string (uri)
customer_uuid string (uuid)
customer_name string
customer_native_name string
customer_abbreviation string
error_message string
error_traceback string
resource_type string
state any
created string (date-time)
modified string (date-time)
backend_id string Load balancer ID in Octavia
access_url any
tenant string (uri) OpenStack tenant this load balancer belongs to
tenant_name string
tenant_uuid string (uuid)
vip_address any An IPv4 or IPv6 address.
vip_subnet string (uri)
vip_port string (uri)
attached_floating_ip string (uri) Floating IP attached to the VIP port
provider string
provisioning_status string
operating_status string
vip_security_groups array of objects Security groups assigned to the VIP port.
vip_security_groups.uuid string
vip_security_groups.name string
vip_security_groups.url string (uri)
marketplace_offering_uuid string
marketplace_offering_name string
marketplace_offering_type string
marketplace_offering_plugin_options object (free-form)
marketplace_category_uuid string
marketplace_category_name string
marketplace_resource_uuid string
marketplace_plan_uuid string
marketplace_resource_state string
is_usage_based boolean
is_limit_based boolean

Get load balancer details

Retrieve details of a specific load balancer.

1
2
3
4
http \
  GET \
  https://api.example.com/api/openstack-loadbalancers/a1b2c3d4-e5f6-7890-abcd-ef1234567890/ \
  Authorization:"Token YOUR_API_TOKEN"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
from waldur_api_client.client import AuthenticatedClient
from waldur_api_client.models.open_stack_load_balancer_field_enum import OpenStackLoadBalancerFieldEnum # (1)
from waldur_api_client.api.openstack_loadbalancers import openstack_loadbalancers_retrieve # (2)

client = AuthenticatedClient(
    base_url="https://api.example.com", token="YOUR_API_TOKEN"
)
response = openstack_loadbalancers_retrieve.sync(
    uuid="a1b2c3d4-e5f6-7890-abcd-ef1234567890",
    client=client
)

print(response)
  1. Model Source: OpenStackLoadBalancerFieldEnum
  2. API Source: openstack_loadbalancers_retrieve
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import { openstackLoadbalancersRetrieve } from 'waldur-js-client';

try {
  const response = await openstackLoadbalancersRetrieve({
  auth: "Token YOUR_API_TOKEN",
  path: {
    "uuid": "a1b2c3d4-e5f6-7890-abcd-ef1234567890"
  }
});
  console.log('Success:', response);
} catch (error) {
  console.error('Error:', error);
}
Name Type Required
uuid string (uuid) ✓
Name Type
field array

200 -

Field Type Description
url string (uri)
uuid string (uuid)
name string
description string
service_name string
service_settings string (uri)
service_settings_uuid string (uuid)
service_settings_state string
service_settings_error_message string
project string (uri)
project_name string
project_uuid string (uuid)
customer string (uri)
customer_uuid string (uuid)
customer_name string
customer_native_name string
customer_abbreviation string
error_message string
error_traceback string
resource_type string
state any
created string (date-time)
modified string (date-time)
backend_id string Load balancer ID in Octavia
access_url any
tenant string (uri) OpenStack tenant this load balancer belongs to
tenant_name string
tenant_uuid string (uuid)
vip_address any An IPv4 or IPv6 address.
vip_subnet string (uri)
vip_port string (uri)
attached_floating_ip string (uri) Floating IP attached to the VIP port
provider string
provisioning_status string
operating_status string
vip_security_groups array of objects Security groups assigned to the VIP port.
vip_security_groups.uuid string
vip_security_groups.name string
vip_security_groups.url string (uri)
marketplace_offering_uuid string
marketplace_offering_name string
marketplace_offering_type string
marketplace_offering_plugin_options object (free-form)
marketplace_category_uuid string
marketplace_category_name string
marketplace_resource_uuid string
marketplace_plan_uuid string
marketplace_resource_state string
is_usage_based boolean
is_limit_based boolean

List pool members

Get a list of pool members.

1
2
3
4
http \
  GET \
  https://api.example.com/api/openstack-pool-members/ \
  Authorization:"Token YOUR_API_TOKEN"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
from waldur_api_client.client import AuthenticatedClient
from waldur_api_client.models.core_states import CoreStates # (1)
from waldur_api_client.models.open_stack_pool_member_field_enum import OpenStackPoolMemberFieldEnum # (2)
from waldur_api_client.api.openstack_pool_members import openstack_pool_members_list # (3)

client = AuthenticatedClient(
    base_url="https://api.example.com", token="YOUR_API_TOKEN"
)
response = openstack_pool_members_list.sync(client=client)

for item in response:
    print(item)
  1. Model Source: CoreStates
  2. Model Source: OpenStackPoolMemberFieldEnum
  3. API Source: openstack_pool_members_list
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
import { openstackPoolMembersList } from 'waldur-js-client';

try {
  const response = await openstackPoolMembersList({
  auth: "Token YOUR_API_TOKEN"
});
  console.log('Success:', response);
} catch (error) {
  console.error('Error:', error);
}
Name Type Description
field array
load_balancer_uuid string (uuid) Load balancer UUID
name string Name
name_exact string Name (exact)
page integer A page number within the paginated result set.
page_size integer Number of results to return per page.
pool string (uri) Pool URL
pool_uuid string (uuid) Pool UUID
state array State
tenant_uuid string (uuid) Tenant UUID

200 -

The response body is an array of objects, where each object has the following structure:

Field Type Description
url string (uri)
uuid string (uuid)
name string
description string
service_name string
service_settings string (uri)
service_settings_uuid string (uuid)
service_settings_state string
service_settings_error_message string
project string (uri)
project_name string
project_uuid string (uuid)
customer string (uri)
customer_uuid string (uuid)
customer_name string
customer_native_name string
customer_abbreviation string
error_message string
error_traceback string
resource_type string
state any
created string (date-time)
modified string (date-time)
backend_id string Member ID in Octavia
access_url any
pool string (uri) Pool this member belongs to
pool_name string
pool_uuid string (uuid)
load_balancer_uuid string (uuid)
address any An IPv4 or IPv6 address.
protocol_port integer
subnet string (uri)
weight integer
provisioning_status string
operating_status string
marketplace_offering_uuid string
marketplace_offering_name string
marketplace_offering_type string
marketplace_offering_plugin_options object (free-form)
marketplace_category_uuid string
marketplace_category_name string
marketplace_resource_uuid string
marketplace_plan_uuid string
marketplace_resource_state string
is_usage_based boolean
is_limit_based boolean

Get pool member details

Retrieve details of a specific pool member.

1
2
3
4
http \
  GET \
  https://api.example.com/api/openstack-pool-members/a1b2c3d4-e5f6-7890-abcd-ef1234567890/ \
  Authorization:"Token YOUR_API_TOKEN"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
from waldur_api_client.client import AuthenticatedClient
from waldur_api_client.models.open_stack_pool_member_field_enum import OpenStackPoolMemberFieldEnum # (1)
from waldur_api_client.api.openstack_pool_members import openstack_pool_members_retrieve # (2)

client = AuthenticatedClient(
    base_url="https://api.example.com", token="YOUR_API_TOKEN"
)
response = openstack_pool_members_retrieve.sync(
    uuid="a1b2c3d4-e5f6-7890-abcd-ef1234567890",
    client=client
)

print(response)
  1. Model Source: OpenStackPoolMemberFieldEnum
  2. API Source: openstack_pool_members_retrieve
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import { openstackPoolMembersRetrieve } from 'waldur-js-client';

try {
  const response = await openstackPoolMembersRetrieve({
  auth: "Token YOUR_API_TOKEN",
  path: {
    "uuid": "a1b2c3d4-e5f6-7890-abcd-ef1234567890"
  }
});
  console.log('Success:', response);
} catch (error) {
  console.error('Error:', error);
}
Name Type Required
uuid string (uuid) ✓
Name Type
field array

200 -

Field Type Description
url string (uri)
uuid string (uuid)
name string
description string
service_name string
service_settings string (uri)
service_settings_uuid string (uuid)
service_settings_state string
service_settings_error_message string
project string (uri)
project_name string
project_uuid string (uuid)
customer string (uri)
customer_uuid string (uuid)
customer_name string
customer_native_name string
customer_abbreviation string
error_message string
error_traceback string
resource_type string
state any
created string (date-time)
modified string (date-time)
backend_id string Member ID in Octavia
access_url any
pool string (uri) Pool this member belongs to
pool_name string
pool_uuid string (uuid)
load_balancer_uuid string (uuid)
address any An IPv4 or IPv6 address.
protocol_port integer
subnet string (uri)
weight integer
provisioning_status string
operating_status string
marketplace_offering_uuid string
marketplace_offering_name string
marketplace_offering_type string
marketplace_offering_plugin_options object (free-form)
marketplace_category_uuid string
marketplace_category_name string
marketplace_resource_uuid string
marketplace_plan_uuid string
marketplace_resource_state string
is_usage_based boolean
is_limit_based boolean

List pools

Get a list of load balancer pools.

1
2
3
4
http \
  GET \
  https://api.example.com/api/openstack-pools/ \
  Authorization:"Token YOUR_API_TOKEN"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
from waldur_api_client.client import AuthenticatedClient
from waldur_api_client.models.core_states import CoreStates # (1)
from waldur_api_client.models.open_stack_pool_field_enum import OpenStackPoolFieldEnum # (2)
from waldur_api_client.api.openstack_pools import openstack_pools_list # (3)

client = AuthenticatedClient(
    base_url="https://api.example.com", token="YOUR_API_TOKEN"
)
response = openstack_pools_list.sync(client=client)

for item in response:
    print(item)
  1. Model Source: CoreStates
  2. Model Source: OpenStackPoolFieldEnum
  3. API Source: openstack_pools_list
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
import { openstackPoolsList } from 'waldur-js-client';

try {
  const response = await openstackPoolsList({
  auth: "Token YOUR_API_TOKEN"
});
  console.log('Success:', response);
} catch (error) {
  console.error('Error:', error);
}
Name Type Description
field array
load_balancer string (uri) Load balancer URL
load_balancer_uuid string (uuid) Load balancer UUID
name string Name
name_exact string Name (exact)
page integer A page number within the paginated result set.
page_size integer Number of results to return per page.
state array State
tenant_uuid string (uuid) Tenant UUID

200 -

The response body is an array of objects, where each object has the following structure:

Field Type Description
url string (uri)
uuid string (uuid)
name string
description string
service_name string
service_settings string (uri)
service_settings_uuid string (uuid)
service_settings_state string
service_settings_error_message string
project string (uri)
project_name string
project_uuid string (uuid)
customer string (uri)
customer_uuid string (uuid)
customer_name string
customer_native_name string
customer_abbreviation string
error_message string
error_traceback string
resource_type string
state any
created string (date-time)
modified string (date-time)
backend_id string Pool ID in Octavia
access_url any
load_balancer string (uri) Load balancer this pool belongs to
load_balancer_name string
load_balancer_uuid string (uuid)
protocol string
lb_algorithm string
provisioning_status string
operating_status string
marketplace_offering_uuid string
marketplace_offering_name string
marketplace_offering_type string
marketplace_offering_plugin_options object (free-form)
marketplace_category_uuid string
marketplace_category_name string
marketplace_resource_uuid string
marketplace_plan_uuid string
marketplace_resource_state string
is_usage_based boolean
is_limit_based boolean

Get pool details

Retrieve details of a specific pool.

1
2
3
4
http \
  GET \
  https://api.example.com/api/openstack-pools/a1b2c3d4-e5f6-7890-abcd-ef1234567890/ \
  Authorization:"Token YOUR_API_TOKEN"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
from waldur_api_client.client import AuthenticatedClient
from waldur_api_client.models.open_stack_pool_field_enum import OpenStackPoolFieldEnum # (1)
from waldur_api_client.api.openstack_pools import openstack_pools_retrieve # (2)

client = AuthenticatedClient(
    base_url="https://api.example.com", token="YOUR_API_TOKEN"
)
response = openstack_pools_retrieve.sync(
    uuid="a1b2c3d4-e5f6-7890-abcd-ef1234567890",
    client=client
)

print(response)
  1. Model Source: OpenStackPoolFieldEnum
  2. API Source: openstack_pools_retrieve
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import { openstackPoolsRetrieve } from 'waldur-js-client';

try {
  const response = await openstackPoolsRetrieve({
  auth: "Token YOUR_API_TOKEN",
  path: {
    "uuid": "a1b2c3d4-e5f6-7890-abcd-ef1234567890"
  }
});
  console.log('Success:', response);
} catch (error) {
  console.error('Error:', error);
}
Name Type Required
uuid string (uuid) ✓
Name Type
field array

200 -

Field Type Description
url string (uri)
uuid string (uuid)
name string
description string
service_name string
service_settings string (uri)
service_settings_uuid string (uuid)
service_settings_state string
service_settings_error_message string
project string (uri)
project_name string
project_uuid string (uuid)
customer string (uri)
customer_uuid string (uuid)
customer_name string
customer_native_name string
customer_abbreviation string
error_message string
error_traceback string
resource_type string
state any
created string (date-time)
modified string (date-time)
backend_id string Pool ID in Octavia
access_url any
load_balancer string (uri) Load balancer this pool belongs to
load_balancer_name string
load_balancer_uuid string (uuid)
protocol string
lb_algorithm string
provisioning_status string
operating_status string
marketplace_offering_uuid string
marketplace_offering_name string
marketplace_offering_type string
marketplace_offering_plugin_options object (free-form)
marketplace_category_uuid string
marketplace_category_name string
marketplace_resource_uuid string
marketplace_plan_uuid string
marketplace_resource_state string
is_usage_based boolean
is_limit_based boolean

Create

1
2
3
4
http \
  POST \
  https://api.example.com/api/openstack/discovery/ \
  Authorization:"Token YOUR_API_TOKEN"

1
2
3
4
5
6
7
8
9
from waldur_api_client.client import AuthenticatedClient
from waldur_api_client.api.openstack import openstack_discovery_create # (1)

client = AuthenticatedClient(
    base_url="https://api.example.com", token="YOUR_API_TOKEN"
)
response = openstack_discovery_create.sync(client=client)

print(response)
  1. API Source: openstack_discovery_create
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
import { openstackDiscoveryCreate } from 'waldur-js-client';

try {
  const response = await openstackDiscoveryCreate({
  auth: "Token YOUR_API_TOKEN"
});
  console.log('Success:', response);
} catch (error) {
  console.error('Error:', error);
}

201 - No response body

Discover available external networks

Discover available external networks.

1
2
3
4
5
6
7
http \
  POST \
  https://api.example.com/api/openstack/discovery/discover_external_networks/ \
  Authorization:"Token YOUR_API_TOKEN" \
  auth_url="https://api.example.com/api/auth-url/a1b2c3d4-e5f6-7890-abcd-ef1234567890/" \
  username="alice" \
  password="********"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
from waldur_api_client.client import AuthenticatedClient
from waldur_api_client.models.discover_external_networks_request_request import DiscoverExternalNetworksRequestRequest # (1)
from waldur_api_client.api.openstack import openstack_discovery_discover_external_networks # (2)

client = AuthenticatedClient(
    base_url="https://api.example.com", token="YOUR_API_TOKEN"
)

body_data = DiscoverExternalNetworksRequestRequest(
    auth_url="https://api.example.com/api/auth-url/a1b2c3d4-e5f6-7890-abcd-ef1234567890/",
    username="alice",
    password="********"
)
response = openstack_discovery_discover_external_networks.sync(
    client=client,
    body=body_data
)

for item in response:
    print(item)
  1. Model Source: DiscoverExternalNetworksRequestRequest
  2. API Source: openstack_discovery_discover_external_networks
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
import { openstackDiscoveryDiscoverExternalNetworks } from 'waldur-js-client';

try {
  const response = await openstackDiscoveryDiscoverExternalNetworks({
  auth: "Token YOUR_API_TOKEN",
  body: {
    "auth_url": "https://api.example.com/api/auth-url/a1b2c3d4-e5f6-7890-abcd-ef1234567890/",
    "username": "alice",
    "password": "********"
  }
});
  console.log('Success:', response);
} catch (error) {
  console.error('Error:', error);
}
Name Type Description
page integer A page number within the paginated result set.
page_size integer Number of results to return per page.
Field Type Required Description
auth_url string (uri) ✓ Keystone auth URL (e.g., https://cloud.example.com:5000/v3)
username string ✓
password string ✓
Constraints: write-only
user_domain_name string Keystone user domain name
Constraints: default: Default
project_domain_name string Keystone project domain name
Constraints: default: Default
project_name string Keystone project (tenant) name
Constraints: default: admin
auth_type any Authentication method: password or v3applicationcredential
Constraints: default: password
verify_ssl boolean
Constraints: default: False
certificate string PEM-encoded CA certificate for SSL verification
Constraints: write-only

200 -

The response body is an array of objects, where each object has the following structure:

Field Type
id string
name string
is_shared boolean
subnets array of objects
subnets.id string
subnets.name string
subnets.cidr string
subnets.gateway_ip string
subnets.ip_version integer

Discover available flavors

Discover available flavors.

1
2
3
4
5
6
7
http \
  POST \
  https://api.example.com/api/openstack/discovery/discover_flavors/ \
  Authorization:"Token YOUR_API_TOKEN" \
  auth_url="https://api.example.com/api/auth-url/a1b2c3d4-e5f6-7890-abcd-ef1234567890/" \
  username="alice" \
  password="********"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
from waldur_api_client.client import AuthenticatedClient
from waldur_api_client.models.discover_flavors_request_request import DiscoverFlavorsRequestRequest # (1)
from waldur_api_client.api.openstack import openstack_discovery_discover_flavors # (2)

client = AuthenticatedClient(
    base_url="https://api.example.com", token="YOUR_API_TOKEN"
)

body_data = DiscoverFlavorsRequestRequest(
    auth_url="https://api.example.com/api/auth-url/a1b2c3d4-e5f6-7890-abcd-ef1234567890/",
    username="alice",
    password="********"
)
response = openstack_discovery_discover_flavors.sync(
    client=client,
    body=body_data
)

for item in response:
    print(item)
  1. Model Source: DiscoverFlavorsRequestRequest
  2. API Source: openstack_discovery_discover_flavors
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
import { openstackDiscoveryDiscoverFlavors } from 'waldur-js-client';

try {
  const response = await openstackDiscoveryDiscoverFlavors({
  auth: "Token YOUR_API_TOKEN",
  body: {
    "auth_url": "https://api.example.com/api/auth-url/a1b2c3d4-e5f6-7890-abcd-ef1234567890/",
    "username": "alice",
    "password": "********"
  }
});
  console.log('Success:', response);
} catch (error) {
  console.error('Error:', error);
}
Name Type Description
page integer A page number within the paginated result set.
page_size integer Number of results to return per page.
Field Type Required Description
auth_url string (uri) ✓ Keystone auth URL (e.g., https://cloud.example.com:5000/v3)
username string ✓
password string ✓
Constraints: write-only
user_domain_name string Keystone user domain name
Constraints: default: Default
project_domain_name string Keystone project domain name
Constraints: default: Default
project_name string Keystone project (tenant) name
Constraints: default: admin
auth_type any Authentication method: password or v3applicationcredential
Constraints: default: password
verify_ssl boolean
Constraints: default: False
certificate string PEM-encoded CA certificate for SSL verification
Constraints: write-only

200 -

The response body is an array of objects, where each object has the following structure:

Field Type Description
id string
name string
vcpus integer
ram integer RAM in MB
disk integer Disk in GB

Discover available Nova instance availability zones

Discover available Nova instance availability zones.

1
2
3
4
5
6
7
http \
  POST \
  https://api.example.com/api/openstack/discovery/discover_instance_availability_zones/ \
  Authorization:"Token YOUR_API_TOKEN" \
  auth_url="https://api.example.com/api/auth-url/a1b2c3d4-e5f6-7890-abcd-ef1234567890/" \
  username="alice" \
  password="********"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
from waldur_api_client.client import AuthenticatedClient
from waldur_api_client.models.discover_instance_availability_zones_request_request import DiscoverInstanceAvailabilityZonesRequestRequest # (1)
from waldur_api_client.api.openstack import openstack_discovery_discover_instance_availability_zones # (2)

client = AuthenticatedClient(
    base_url="https://api.example.com", token="YOUR_API_TOKEN"
)

body_data = DiscoverInstanceAvailabilityZonesRequestRequest(
    auth_url="https://api.example.com/api/auth-url/a1b2c3d4-e5f6-7890-abcd-ef1234567890/",
    username="alice",
    password="********"
)
response = openstack_discovery_discover_instance_availability_zones.sync(
    client=client,
    body=body_data
)

for item in response:
    print(item)
  1. Model Source: DiscoverInstanceAvailabilityZonesRequestRequest
  2. API Source: openstack_discovery_discover_instance_availability_zones
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
import { openstackDiscoveryDiscoverInstanceAvailabilityZones } from 'waldur-js-client';

try {
  const response = await openstackDiscoveryDiscoverInstanceAvailabilityZones({
  auth: "Token YOUR_API_TOKEN",
  body: {
    "auth_url": "https://api.example.com/api/auth-url/a1b2c3d4-e5f6-7890-abcd-ef1234567890/",
    "username": "alice",
    "password": "********"
  }
});
  console.log('Success:', response);
} catch (error) {
  console.error('Error:', error);
}
Name Type Description
page integer A page number within the paginated result set.
page_size integer Number of results to return per page.
Field Type Required Description
auth_url string (uri) ✓ Keystone auth URL (e.g., https://cloud.example.com:5000/v3)
username string ✓
password string ✓
Constraints: write-only
user_domain_name string Keystone user domain name
Constraints: default: Default
project_domain_name string Keystone project domain name
Constraints: default: Default
project_name string Keystone project (tenant) name
Constraints: default: admin
auth_type any Authentication method: password or v3applicationcredential
Constraints: default: password
verify_ssl boolean
Constraints: default: False
certificate string PEM-encoded CA certificate for SSL verification
Constraints: write-only

200 -

The response body is an array of objects, where each object has the following structure:

Field Type
name string
state string

Discover available Cinder volume availability zones

Discover available Cinder volume availability zones.

1
2
3
4
5
6
7
http \
  POST \
  https://api.example.com/api/openstack/discovery/discover_volume_availability_zones/ \
  Authorization:"Token YOUR_API_TOKEN" \
  auth_url="https://api.example.com/api/auth-url/a1b2c3d4-e5f6-7890-abcd-ef1234567890/" \
  username="alice" \
  password="********"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
from waldur_api_client.client import AuthenticatedClient
from waldur_api_client.models.discover_volume_availability_zones_request_request import DiscoverVolumeAvailabilityZonesRequestRequest # (1)
from waldur_api_client.api.openstack import openstack_discovery_discover_volume_availability_zones # (2)

client = AuthenticatedClient(
    base_url="https://api.example.com", token="YOUR_API_TOKEN"
)

body_data = DiscoverVolumeAvailabilityZonesRequestRequest(
    auth_url="https://api.example.com/api/auth-url/a1b2c3d4-e5f6-7890-abcd-ef1234567890/",
    username="alice",
    password="********"
)
response = openstack_discovery_discover_volume_availability_zones.sync(
    client=client,
    body=body_data
)

for item in response:
    print(item)
  1. Model Source: DiscoverVolumeAvailabilityZonesRequestRequest
  2. API Source: openstack_discovery_discover_volume_availability_zones
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
import { openstackDiscoveryDiscoverVolumeAvailabilityZones } from 'waldur-js-client';

try {
  const response = await openstackDiscoveryDiscoverVolumeAvailabilityZones({
  auth: "Token YOUR_API_TOKEN",
  body: {
    "auth_url": "https://api.example.com/api/auth-url/a1b2c3d4-e5f6-7890-abcd-ef1234567890/",
    "username": "alice",
    "password": "********"
  }
});
  console.log('Success:', response);
} catch (error) {
  console.error('Error:', error);
}
Name Type Description
page integer A page number within the paginated result set.
page_size integer Number of results to return per page.
Field Type Required Description
auth_url string (uri) ✓ Keystone auth URL (e.g., https://cloud.example.com:5000/v3)
username string ✓
password string ✓
Constraints: write-only
user_domain_name string Keystone user domain name
Constraints: default: Default
project_domain_name string Keystone project domain name
Constraints: default: Default
project_name string Keystone project (tenant) name
Constraints: default: admin
auth_type any Authentication method: password or v3applicationcredential
Constraints: default: password
verify_ssl boolean
Constraints: default: False
certificate string PEM-encoded CA certificate for SSL verification
Constraints: write-only

200 -

The response body is an array of objects, where each object has the following structure:

Field Type
name string
state string

Discover available volume types

Discover available volume types.

1
2
3
4
5
6
7
http \
  POST \
  https://api.example.com/api/openstack/discovery/discover_volume_types/ \
  Authorization:"Token YOUR_API_TOKEN" \
  auth_url="https://api.example.com/api/auth-url/a1b2c3d4-e5f6-7890-abcd-ef1234567890/" \
  username="alice" \
  password="********"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
from waldur_api_client.client import AuthenticatedClient
from waldur_api_client.models.discover_volume_types_request_request import DiscoverVolumeTypesRequestRequest # (1)
from waldur_api_client.api.openstack import openstack_discovery_discover_volume_types # (2)

client = AuthenticatedClient(
    base_url="https://api.example.com", token="YOUR_API_TOKEN"
)

body_data = DiscoverVolumeTypesRequestRequest(
    auth_url="https://api.example.com/api/auth-url/a1b2c3d4-e5f6-7890-abcd-ef1234567890/",
    username="alice",
    password="********"
)
response = openstack_discovery_discover_volume_types.sync(
    client=client,
    body=body_data
)

for item in response:
    print(item)
  1. Model Source: DiscoverVolumeTypesRequestRequest
  2. API Source: openstack_discovery_discover_volume_types
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
import { openstackDiscoveryDiscoverVolumeTypes } from 'waldur-js-client';

try {
  const response = await openstackDiscoveryDiscoverVolumeTypes({
  auth: "Token YOUR_API_TOKEN",
  body: {
    "auth_url": "https://api.example.com/api/auth-url/a1b2c3d4-e5f6-7890-abcd-ef1234567890/",
    "username": "alice",
    "password": "********"
  }
});
  console.log('Success:', response);
} catch (error) {
  console.error('Error:', error);
}
Name Type Description
page integer A page number within the paginated result set.
page_size integer Number of results to return per page.
Field Type Required Description
auth_url string (uri) ✓ Keystone auth URL (e.g., https://cloud.example.com:5000/v3)
username string ✓
password string ✓
Constraints: write-only
user_domain_name string Keystone user domain name
Constraints: default: Default
project_domain_name string Keystone project domain name
Constraints: default: Default
project_name string Keystone project (tenant) name
Constraints: default: admin
auth_type any Authentication method: password or v3applicationcredential
Constraints: default: password
verify_ssl boolean
Constraints: default: False
certificate string PEM-encoded CA certificate for SSL verification
Constraints: write-only

200 -

The response body is an array of objects, where each object has the following structure:

Field Type
id string
name string
description string

Build service_attributes and plugin_options from selected values

Build service_attributes and plugin_options from selected values.

1
2
3
4
5
6
7
http \
  POST \
  https://api.example.com/api/openstack/discovery/preview_service_attributes/ \
  Authorization:"Token YOUR_API_TOKEN" \
  auth_url="https://api.example.com/api/auth-url/a1b2c3d4-e5f6-7890-abcd-ef1234567890/" \
  username="alice" \
  password="********"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
from waldur_api_client.client import AuthenticatedClient
from waldur_api_client.models.preview_service_attributes_request_request import PreviewServiceAttributesRequestRequest # (1)
from waldur_api_client.api.openstack import openstack_discovery_preview_service_attributes # (2)

client = AuthenticatedClient(
    base_url="https://api.example.com", token="YOUR_API_TOKEN"
)

body_data = PreviewServiceAttributesRequestRequest(
    auth_url="https://api.example.com/api/auth-url/a1b2c3d4-e5f6-7890-abcd-ef1234567890/",
    username="alice",
    password="********"
)
response = openstack_discovery_preview_service_attributes.sync(
    client=client,
    body=body_data
)

print(response)
  1. Model Source: PreviewServiceAttributesRequestRequest
  2. API Source: openstack_discovery_preview_service_attributes
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
import { openstackDiscoveryPreviewServiceAttributes } from 'waldur-js-client';

try {
  const response = await openstackDiscoveryPreviewServiceAttributes({
  auth: "Token YOUR_API_TOKEN",
  body: {
    "auth_url": "https://api.example.com/api/auth-url/a1b2c3d4-e5f6-7890-abcd-ef1234567890/",
    "username": "alice",
    "password": "********"
  }
});
  console.log('Success:', response);
} catch (error) {
  console.error('Error:', error);
}
Field Type Required Description
auth_url string (uri) ✓ Keystone auth URL (e.g., https://cloud.example.com:5000/v3)
username string ✓
password string ✓
Constraints: write-only
user_domain_name string Keystone user domain name
Constraints: default: Default
project_domain_name string Keystone project domain name
Constraints: default: Default
project_name string Keystone project (tenant) name
Constraints: default: admin
auth_type any Authentication method: password or v3applicationcredential
Constraints: default: password
verify_ssl boolean
Constraints: default: False
certificate string PEM-encoded CA certificate for SSL verification
Constraints: write-only
external_network_id string Selected external network ID
Constraints: default: ``
instance_availability_zone string Selected instance availability zone name
Constraints: default: ``
volume_availability_zone string Selected volume availability zone name
Constraints: default: ``

200 -

Field Type
service_attributes object (free-form)
plugin_options object (free-form)

Validate OpenStack credentials without saving them

Validate OpenStack credentials without saving them.

1
2
3
4
5
6
7
http \
  POST \
  https://api.example.com/api/openstack/discovery/validate_credentials/ \
  Authorization:"Token YOUR_API_TOKEN" \
  auth_url="https://api.example.com/api/auth-url/a1b2c3d4-e5f6-7890-abcd-ef1234567890/" \
  username="alice" \
  password="********"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
from waldur_api_client.client import AuthenticatedClient
from waldur_api_client.models.open_stack_credentials_request import OpenStackCredentialsRequest # (1)
from waldur_api_client.api.openstack import openstack_discovery_validate_credentials # (2)

client = AuthenticatedClient(
    base_url="https://api.example.com", token="YOUR_API_TOKEN"
)

body_data = OpenStackCredentialsRequest(
    auth_url="https://api.example.com/api/auth-url/a1b2c3d4-e5f6-7890-abcd-ef1234567890/",
    username="alice",
    password="********"
)
response = openstack_discovery_validate_credentials.sync(
    client=client,
    body=body_data
)

print(response)
  1. Model Source: OpenStackCredentialsRequest
  2. API Source: openstack_discovery_validate_credentials
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
import { openstackDiscoveryValidateCredentials } from 'waldur-js-client';

try {
  const response = await openstackDiscoveryValidateCredentials({
  auth: "Token YOUR_API_TOKEN",
  body: {
    "auth_url": "https://api.example.com/api/auth-url/a1b2c3d4-e5f6-7890-abcd-ef1234567890/",
    "username": "alice",
    "password": "********"
  }
});
  console.log('Success:', response);
} catch (error) {
  console.error('Error:', error);
}
Field Type Required Description
auth_url string (uri) ✓ Keystone auth URL (e.g., https://cloud.example.com:5000/v3)
username string ✓
password string ✓
Constraints: write-only
user_domain_name string Keystone user domain name
Constraints: default: Default
project_domain_name string Keystone project domain name
Constraints: default: Default
project_name string Keystone project (tenant) name
Constraints: default: admin
auth_type any Authentication method: password or v3applicationcredential
Constraints: default: password
verify_ssl boolean
Constraints: default: False
certificate string PEM-encoded CA certificate for SSL verification
Constraints: write-only

200 -

Field Type
valid boolean
message string
error string
server_info any

Create health monitor

Create a new health monitor for a pool.

1
2
3
4
5
6
http \
  POST \
  https://api.example.com/api/openstack-health-monitors/ \
  Authorization:"Token YOUR_API_TOKEN" \
  pool="https://api.example.com/api/pool/a1b2c3d4-e5f6-7890-abcd-ef1234567890/" \
  type="TCP"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
from waldur_api_client.client import AuthenticatedClient
from waldur_api_client.models.create_health_monitor_request import CreateHealthMonitorRequest # (1)
from waldur_api_client.api.openstack_health_monitors import openstack_health_monitors_create # (2)

client = AuthenticatedClient(
    base_url="https://api.example.com", token="YOUR_API_TOKEN"
)

body_data = CreateHealthMonitorRequest(
    pool="https://api.example.com/api/pool/a1b2c3d4-e5f6-7890-abcd-ef1234567890/",
    type="TCP"
)
response = openstack_health_monitors_create.sync(
    client=client,
    body=body_data
)

print(response)
  1. Model Source: CreateHealthMonitorRequest
  2. API Source: openstack_health_monitors_create
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
import { openstackHealthMonitorsCreate } from 'waldur-js-client';

try {
  const response = await openstackHealthMonitorsCreate({
  auth: "Token YOUR_API_TOKEN",
  body: {
    "pool": "https://api.example.com/api/pool/a1b2c3d4-e5f6-7890-abcd-ef1234567890/",
    "type": "TCP"
  }
});
  console.log('Success:', response);
} catch (error) {
  console.error('Error:', error);
}
Field Type Required Description
name string
delay integer Interval between health checks in seconds
Constraints: default: 5
timeout integer Time in seconds to timeout a health check
Constraints: default: 5
max_retries integer
Constraints: default: 3
max_retries_down integer
Constraints: default: 3
pool string (uri) ✓ Pool this health monitor belongs to
type string ✓
Enum: TCP, UDP

201 -

Field Type Description
url string (uri)
uuid string (uuid)
name string
delay integer Interval between health checks in seconds
timeout integer Time in seconds to timeout a health check
max_retries integer
max_retries_down integer
pool string (uri) Pool this health monitor belongs to
type string
Enum: TCP, UDP

Pull health monitor

Synchronize health monitor state from the OpenStack backend. Also pulls the associated pool and load balancer.

1
2
3
4
http \
  POST \
  https://api.example.com/api/openstack-health-monitors/a1b2c3d4-e5f6-7890-abcd-ef1234567890/pull/ \
  Authorization:"Token YOUR_API_TOKEN"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
from waldur_api_client.client import AuthenticatedClient
from waldur_api_client.api.openstack_health_monitors import openstack_health_monitors_pull # (1)

client = AuthenticatedClient(
    base_url="https://api.example.com", token="YOUR_API_TOKEN"
)
response = openstack_health_monitors_pull.sync(
    uuid="a1b2c3d4-e5f6-7890-abcd-ef1234567890",
    client=client
)

print(response)
  1. API Source: openstack_health_monitors_pull
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import { openstackHealthMonitorsPull } from 'waldur-js-client';

try {
  const response = await openstackHealthMonitorsPull({
  auth: "Token YOUR_API_TOKEN",
  path: {
    "uuid": "a1b2c3d4-e5f6-7890-abcd-ef1234567890"
  }
});
  console.log('Success:', response);
} catch (error) {
  console.error('Error:', error);
}
Name Type Required
uuid string (uuid) ✓

202 - No response body

Create listener

Create a new listener for a load balancer.

1
2
3
4
5
6
7
http \
  POST \
  https://api.example.com/api/openstack-listeners/ \
  Authorization:"Token YOUR_API_TOKEN" \
  load_balancer="https://api.example.com/api/load-balancer/a1b2c3d4-e5f6-7890-abcd-ef1234567890/" \
  protocol="TCP" \
  protocol_port=8080

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
from waldur_api_client.client import AuthenticatedClient
from waldur_api_client.models.create_listener_request import CreateListenerRequest # (1)
from waldur_api_client.api.openstack_listeners import openstack_listeners_create # (2)

client = AuthenticatedClient(
    base_url="https://api.example.com", token="YOUR_API_TOKEN"
)

body_data = CreateListenerRequest(
    load_balancer="https://api.example.com/api/load-balancer/a1b2c3d4-e5f6-7890-abcd-ef1234567890/",
    protocol="TCP",
    protocol_port=8080
)
response = openstack_listeners_create.sync(
    client=client,
    body=body_data
)

print(response)
  1. Model Source: CreateListenerRequest
  2. API Source: openstack_listeners_create
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
import { openstackListenersCreate } from 'waldur-js-client';

try {
  const response = await openstackListenersCreate({
  auth: "Token YOUR_API_TOKEN",
  body: {
    "load_balancer": "https://api.example.com/api/load-balancer/a1b2c3d4-e5f6-7890-abcd-ef1234567890/",
    "protocol": "TCP",
    "protocol_port": 8080
  }
});
  console.log('Success:', response);
} catch (error) {
  console.error('Error:', error);
}
Field Type Required Description
name string
default_pool string (uri)
load_balancer string (uri) ✓ Load balancer this listener belongs to
protocol string ✓
Enum: TCP, UDP
protocol_port integer ✓ Port on which the listener listens

201 -

Field Type Description
name string
default_pool string (uri)
url string (uri)
uuid string (uuid)
load_balancer string (uri) Load balancer this listener belongs to
protocol string
Enum: TCP, UDP
protocol_port integer Port on which the listener listens

Pull listener

Synchronize listener state from the OpenStack backend. Also pulls pools of the load balancer and the load balancer itself.

1
2
3
4
http \
  POST \
  https://api.example.com/api/openstack-listeners/a1b2c3d4-e5f6-7890-abcd-ef1234567890/pull/ \
  Authorization:"Token YOUR_API_TOKEN"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
from waldur_api_client.client import AuthenticatedClient
from waldur_api_client.api.openstack_listeners import openstack_listeners_pull # (1)

client = AuthenticatedClient(
    base_url="https://api.example.com", token="YOUR_API_TOKEN"
)
response = openstack_listeners_pull.sync(
    uuid="a1b2c3d4-e5f6-7890-abcd-ef1234567890",
    client=client
)

print(response)
  1. API Source: openstack_listeners_pull
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import { openstackListenersPull } from 'waldur-js-client';

try {
  const response = await openstackListenersPull({
  auth: "Token YOUR_API_TOKEN",
  path: {
    "uuid": "a1b2c3d4-e5f6-7890-abcd-ef1234567890"
  }
});
  console.log('Success:', response);
} catch (error) {
  console.error('Error:', error);
}
Name Type Required
uuid string (uuid) ✓

202 - No response body

Attach floating IP to VIP

Attach a floating IP to the load balancer VIP port.

1
2
3
4
5
http \
  POST \
  https://api.example.com/api/openstack-loadbalancers/a1b2c3d4-e5f6-7890-abcd-ef1234567890/attach_floating_ip/ \
  Authorization:"Token YOUR_API_TOKEN" \
  floating_ip="8.8.8.8"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
from waldur_api_client.client import AuthenticatedClient
from waldur_api_client.models.load_balancer_attach_floating_ip_request import LoadBalancerAttachFloatingIPRequest # (1)
from waldur_api_client.api.openstack_loadbalancers import openstack_loadbalancers_attach_floating_ip # (2)

client = AuthenticatedClient(
    base_url="https://api.example.com", token="YOUR_API_TOKEN"
)

body_data = LoadBalancerAttachFloatingIPRequest(
    floating_ip="8.8.8.8"
)
response = openstack_loadbalancers_attach_floating_ip.sync(
    uuid="a1b2c3d4-e5f6-7890-abcd-ef1234567890",
    client=client,
    body=body_data
)

print(response)
  1. Model Source: LoadBalancerAttachFloatingIPRequest
  2. API Source: openstack_loadbalancers_attach_floating_ip
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
import { openstackLoadbalancersAttachFloatingIp } from 'waldur-js-client';

try {
  const response = await openstackLoadbalancersAttachFloatingIp({
  auth: "Token YOUR_API_TOKEN",
  path: {
    "uuid": "a1b2c3d4-e5f6-7890-abcd-ef1234567890"
  },
  body: {
    "floating_ip": "8.8.8.8"
  }
});
  console.log('Success:', response);
} catch (error) {
  console.error('Error:', error);
}
Name Type Required
uuid string (uuid) ✓
Field Type Required
floating_ip string (uri) ✓

202 -

Field Type
status string

Create load balancer

Create a new load balancer.

1
2
3
4
5
6
7
http \
  POST \
  https://api.example.com/api/openstack-loadbalancers/ \
  Authorization:"Token YOUR_API_TOKEN" \
  name="my-awesome-openstack-loadbalancer" \
  tenant="https://api.example.com/api/tenant/a1b2c3d4-e5f6-7890-abcd-ef1234567890/" \
  vip_subnet="https://api.example.com/api/vip-subnet/a1b2c3d4-e5f6-7890-abcd-ef1234567890/"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
from waldur_api_client.client import AuthenticatedClient
from waldur_api_client.models.create_load_balancer_request import CreateLoadBalancerRequest # (1)
from waldur_api_client.api.openstack_loadbalancers import openstack_loadbalancers_create # (2)

client = AuthenticatedClient(
    base_url="https://api.example.com", token="YOUR_API_TOKEN"
)

body_data = CreateLoadBalancerRequest(
    name="my-awesome-openstack-loadbalancer",
    tenant="https://api.example.com/api/tenant/a1b2c3d4-e5f6-7890-abcd-ef1234567890/",
    vip_subnet="https://api.example.com/api/vip-subnet/a1b2c3d4-e5f6-7890-abcd-ef1234567890/"
)
response = openstack_loadbalancers_create.sync(
    client=client,
    body=body_data
)

print(response)
  1. Model Source: CreateLoadBalancerRequest
  2. API Source: openstack_loadbalancers_create
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
import { openstackLoadbalancersCreate } from 'waldur-js-client';

try {
  const response = await openstackLoadbalancersCreate({
  auth: "Token YOUR_API_TOKEN",
  body: {
    "name": "my-awesome-openstack-loadbalancer",
    "tenant": "https://api.example.com/api/tenant/a1b2c3d4-e5f6-7890-abcd-ef1234567890/",
    "vip_subnet": "https://api.example.com/api/vip-subnet/a1b2c3d4-e5f6-7890-abcd-ef1234567890/"
  }
});
  console.log('Success:', response);
} catch (error) {
  console.error('Error:', error);
}
Field Type Required Description
name string ✓
tenant string (uri) ✓ OpenStack tenant this load balancer belongs to
vip_subnet string (uri) ✓

201 -

Field Type Description
url string (uri)
uuid string (uuid)
name string
tenant string (uri) OpenStack tenant this load balancer belongs to
vip_subnet string (uri)

Detach floating IP from VIP

Detach floating IP from the load balancer VIP port.

1
2
3
4
http \
  POST \
  https://api.example.com/api/openstack-loadbalancers/a1b2c3d4-e5f6-7890-abcd-ef1234567890/detach_floating_ip/ \
  Authorization:"Token YOUR_API_TOKEN"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
from waldur_api_client.client import AuthenticatedClient
from waldur_api_client.api.openstack_loadbalancers import openstack_loadbalancers_detach_floating_ip # (1)

client = AuthenticatedClient(
    base_url="https://api.example.com", token="YOUR_API_TOKEN"
)
response = openstack_loadbalancers_detach_floating_ip.sync(
    uuid="a1b2c3d4-e5f6-7890-abcd-ef1234567890",
    client=client
)

print(response)
  1. API Source: openstack_loadbalancers_detach_floating_ip
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import { openstackLoadbalancersDetachFloatingIp } from 'waldur-js-client';

try {
  const response = await openstackLoadbalancersDetachFloatingIp({
  auth: "Token YOUR_API_TOKEN",
  path: {
    "uuid": "a1b2c3d4-e5f6-7890-abcd-ef1234567890"
  }
});
  console.log('Success:', response);
} catch (error) {
  console.error('Error:', error);
}
Name Type Required
uuid string (uuid) ✓

202 -

Field Type
status string

Pull load balancer

Synchronize load balancer state from the OpenStack backend.

1
2
3
4
http \
  POST \
  https://api.example.com/api/openstack-loadbalancers/a1b2c3d4-e5f6-7890-abcd-ef1234567890/pull/ \
  Authorization:"Token YOUR_API_TOKEN"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
from waldur_api_client.client import AuthenticatedClient
from waldur_api_client.api.openstack_loadbalancers import openstack_loadbalancers_pull # (1)

client = AuthenticatedClient(
    base_url="https://api.example.com", token="YOUR_API_TOKEN"
)
response = openstack_loadbalancers_pull.sync(
    uuid="a1b2c3d4-e5f6-7890-abcd-ef1234567890",
    client=client
)

print(response)
  1. API Source: openstack_loadbalancers_pull
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import { openstackLoadbalancersPull } from 'waldur-js-client';

try {
  const response = await openstackLoadbalancersPull({
  auth: "Token YOUR_API_TOKEN",
  path: {
    "uuid": "a1b2c3d4-e5f6-7890-abcd-ef1234567890"
  }
});
  console.log('Success:', response);
} catch (error) {
  console.error('Error:', error);
}
Name Type Required
uuid string (uuid) ✓

202 - No response body

Set security groups on VIP port

Set security groups on the load balancer VIP port to control access.

1
2
3
4
5
http \
  POST \
  https://api.example.com/api/openstack-loadbalancers/a1b2c3d4-e5f6-7890-abcd-ef1234567890/set_security_groups/ \
  Authorization:"Token YOUR_API_TOKEN" \
  security_groups:='["web-server-sg"]'

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
from waldur_api_client.client import AuthenticatedClient
from waldur_api_client.models.load_balancer_set_security_groups_request import LoadBalancerSetSecurityGroupsRequest # (1)
from waldur_api_client.api.openstack_loadbalancers import openstack_loadbalancers_set_security_groups # (2)

client = AuthenticatedClient(
    base_url="https://api.example.com", token="YOUR_API_TOKEN"
)

body_data = LoadBalancerSetSecurityGroupsRequest(
    security_groups=[
            "web-server-sg"
        ]
)
response = openstack_loadbalancers_set_security_groups.sync(
    uuid="a1b2c3d4-e5f6-7890-abcd-ef1234567890",
    client=client,
    body=body_data
)

print(response)
  1. Model Source: LoadBalancerSetSecurityGroupsRequest
  2. API Source: openstack_loadbalancers_set_security_groups
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
import { openstackLoadbalancersSetSecurityGroups } from 'waldur-js-client';

try {
  const response = await openstackLoadbalancersSetSecurityGroups({
  auth: "Token YOUR_API_TOKEN",
  path: {
    "uuid": "a1b2c3d4-e5f6-7890-abcd-ef1234567890"
  },
  body: {
    "security_groups": [
      "web-server-sg"
    ]
  }
});
  console.log('Success:', response);
} catch (error) {
  console.error('Error:', error);
}
Name Type Required
uuid string (uuid) ✓
Field Type Required
security_groups array of string (uri)s ✓

202 -

Field Type
status string

Delete the load balancer from the Waldur database without scheduling operations on the OpenStack backend and without checking resource state. Staff-only; intended for cleaning up records stuck in transitional states.

1
2
3
4
http \
  POST \
  https://api.example.com/api/openstack-loadbalancers/a1b2c3d4-e5f6-7890-abcd-ef1234567890/unlink/ \
  Authorization:"Token YOUR_API_TOKEN"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
from waldur_api_client.client import AuthenticatedClient
from waldur_api_client.api.openstack_loadbalancers import openstack_loadbalancers_unlink # (1)

client = AuthenticatedClient(
    base_url="https://api.example.com", token="YOUR_API_TOKEN"
)
response = openstack_loadbalancers_unlink.sync(
    uuid="a1b2c3d4-e5f6-7890-abcd-ef1234567890",
    client=client
)

print(response)
  1. API Source: openstack_loadbalancers_unlink
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import { openstackLoadbalancersUnlink } from 'waldur-js-client';

try {
  const response = await openstackLoadbalancersUnlink({
  auth: "Token YOUR_API_TOKEN",
  path: {
    "uuid": "a1b2c3d4-e5f6-7890-abcd-ef1234567890"
  }
});
  console.log('Success:', response);
} catch (error) {
  console.error('Error:', error);
}
Name Type Required
uuid string (uuid) ✓

204 - No response body

Create pool member

Create a new member for a pool.

1
2
3
4
5
6
7
8
http \
  POST \
  https://api.example.com/api/openstack-pool-members/ \
  Authorization:"Token YOUR_API_TOKEN" \
  pool="https://api.example.com/api/pool/a1b2c3d4-e5f6-7890-abcd-ef1234567890/" \
  address=null \
  protocol_port=8080 \
  subnet="https://api.example.com/api/subnet/a1b2c3d4-e5f6-7890-abcd-ef1234567890/"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
from waldur_api_client.client import AuthenticatedClient
from waldur_api_client.models.create_pool_member_request import CreatePoolMemberRequest # (1)
from waldur_api_client.api.openstack_pool_members import openstack_pool_members_create # (2)

client = AuthenticatedClient(
    base_url="https://api.example.com", token="YOUR_API_TOKEN"
)

body_data = CreatePoolMemberRequest(
    pool="https://api.example.com/api/pool/a1b2c3d4-e5f6-7890-abcd-ef1234567890/",
    address=null,
    protocol_port=8080,
    subnet="https://api.example.com/api/subnet/a1b2c3d4-e5f6-7890-abcd-ef1234567890/"
)
response = openstack_pool_members_create.sync(
    client=client,
    body=body_data
)

print(response)
  1. Model Source: CreatePoolMemberRequest
  2. API Source: openstack_pool_members_create
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
import { openstackPoolMembersCreate } from 'waldur-js-client';

try {
  const response = await openstackPoolMembersCreate({
  auth: "Token YOUR_API_TOKEN",
  body: {
    "pool": "https://api.example.com/api/pool/a1b2c3d4-e5f6-7890-abcd-ef1234567890/",
    "address": null,
    "protocol_port": 8080,
    "subnet": "https://api.example.com/api/subnet/a1b2c3d4-e5f6-7890-abcd-ef1234567890/"
  }
});
  console.log('Success:', response);
} catch (error) {
  console.error('Error:', error);
}
Field Type Required Description
name string
weight integer
Constraints: default: 1
pool string (uri) ✓ Pool this member belongs to
address any ✓ An IPv4 or IPv6 address.
protocol_port integer ✓ Port on the backend server
subnet string (uri) ✓

201 -

Field Type Description
url string (uri)
uuid string (uuid)
name string
weight integer
pool string (uri) Pool this member belongs to
address any An IPv4 or IPv6 address.
protocol_port integer Port on the backend server
subnet string (uri)

Pull pool member

Synchronize pool member state from the OpenStack backend. Also pulls the associated pool and load balancer.

1
2
3
4
http \
  POST \
  https://api.example.com/api/openstack-pool-members/a1b2c3d4-e5f6-7890-abcd-ef1234567890/pull/ \
  Authorization:"Token YOUR_API_TOKEN"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
from waldur_api_client.client import AuthenticatedClient
from waldur_api_client.api.openstack_pool_members import openstack_pool_members_pull # (1)

client = AuthenticatedClient(
    base_url="https://api.example.com", token="YOUR_API_TOKEN"
)
response = openstack_pool_members_pull.sync(
    uuid="a1b2c3d4-e5f6-7890-abcd-ef1234567890",
    client=client
)

print(response)
  1. API Source: openstack_pool_members_pull
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import { openstackPoolMembersPull } from 'waldur-js-client';

try {
  const response = await openstackPoolMembersPull({
  auth: "Token YOUR_API_TOKEN",
  path: {
    "uuid": "a1b2c3d4-e5f6-7890-abcd-ef1234567890"
  }
});
  console.log('Success:', response);
} catch (error) {
  console.error('Error:', error);
}
Name Type Required
uuid string (uuid) ✓

202 - No response body

Create pool

Create a new pool for a load balancer.

1
2
3
4
5
6
7
http \
  POST \
  https://api.example.com/api/openstack-pools/ \
  Authorization:"Token YOUR_API_TOKEN" \
  name="my-awesome-openstack-pool" \
  load_balancer="https://api.example.com/api/load-balancer/a1b2c3d4-e5f6-7890-abcd-ef1234567890/" \
  protocol="TCP"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
from waldur_api_client.client import AuthenticatedClient
from waldur_api_client.models.create_pool_request import CreatePoolRequest # (1)
from waldur_api_client.api.openstack_pools import openstack_pools_create # (2)

client = AuthenticatedClient(
    base_url="https://api.example.com", token="YOUR_API_TOKEN"
)

body_data = CreatePoolRequest(
    name="my-awesome-openstack-pool",
    load_balancer="https://api.example.com/api/load-balancer/a1b2c3d4-e5f6-7890-abcd-ef1234567890/",
    protocol="TCP"
)
response = openstack_pools_create.sync(
    client=client,
    body=body_data
)

print(response)
  1. Model Source: CreatePoolRequest
  2. API Source: openstack_pools_create
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
import { openstackPoolsCreate } from 'waldur-js-client';

try {
  const response = await openstackPoolsCreate({
  auth: "Token YOUR_API_TOKEN",
  body: {
    "name": "my-awesome-openstack-pool",
    "load_balancer": "https://api.example.com/api/load-balancer/a1b2c3d4-e5f6-7890-abcd-ef1234567890/",
    "protocol": "TCP"
  }
});
  console.log('Success:', response);
} catch (error) {
  console.error('Error:', error);
}
Field Type Required Description
name string ✓
load_balancer string (uri) ✓ Load balancer this pool belongs to
protocol string ✓
Enum: TCP, UDP
lb_algorithm any
Constraints: default: SOURCE_IP_PORT

201 -

Field Type Description
url string (uri)
uuid string (uuid)
name string
load_balancer string (uri) Load balancer this pool belongs to
protocol string
Enum: TCP, UDP
lb_algorithm any

Pull pool

Synchronize pool state from the OpenStack backend. Also pulls the associated load balancer.

1
2
3
4
http \
  POST \
  https://api.example.com/api/openstack-pools/a1b2c3d4-e5f6-7890-abcd-ef1234567890/pull/ \
  Authorization:"Token YOUR_API_TOKEN"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
from waldur_api_client.client import AuthenticatedClient
from waldur_api_client.api.openstack_pools import openstack_pools_pull # (1)

client = AuthenticatedClient(
    base_url="https://api.example.com", token="YOUR_API_TOKEN"
)
response = openstack_pools_pull.sync(
    uuid="a1b2c3d4-e5f6-7890-abcd-ef1234567890",
    client=client
)

print(response)
  1. API Source: openstack_pools_pull
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import { openstackPoolsPull } from 'waldur-js-client';

try {
  const response = await openstackPoolsPull({
  auth: "Token YOUR_API_TOKEN",
  path: {
    "uuid": "a1b2c3d4-e5f6-7890-abcd-ef1234567890"
  }
});
  console.log('Success:', response);
} catch (error) {
  console.error('Error:', error);
}
Name Type Required
uuid string (uuid) ✓

202 - No response body

Update

1
2
3
4
http \
  PUT \
  https://api.example.com/api/openstack/discovery/123/ \
  Authorization:"Token YOUR_API_TOKEN"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
from waldur_api_client.client import AuthenticatedClient
from waldur_api_client.api.openstack import openstack_discovery_update # (1)

client = AuthenticatedClient(
    base_url="https://api.example.com", token="YOUR_API_TOKEN"
)
response = openstack_discovery_update.sync(
    id=123,
    client=client
)

print(response)
  1. API Source: openstack_discovery_update
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import { openstackDiscoveryUpdate } from 'waldur-js-client';

try {
  const response = await openstackDiscoveryUpdate({
  auth: "Token YOUR_API_TOKEN",
  path: {
    "id": 123
  }
});
  console.log('Success:', response);
} catch (error) {
  console.error('Error:', error);
}
Name Type Required Description
id integer ✓ A unique integer value identifying this Service provider.

200 - No response body

Update health monitor

Update an existing health monitor.

1
2
3
4
http \
  PUT \
  https://api.example.com/api/openstack-health-monitors/a1b2c3d4-e5f6-7890-abcd-ef1234567890/ \
  Authorization:"Token YOUR_API_TOKEN"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
from waldur_api_client.client import AuthenticatedClient
from waldur_api_client.models.update_health_monitor_request import UpdateHealthMonitorRequest # (1)
from waldur_api_client.api.openstack_health_monitors import openstack_health_monitors_update # (2)

client = AuthenticatedClient(
    base_url="https://api.example.com", token="YOUR_API_TOKEN"
)

body_data = UpdateHealthMonitorRequest()
response = openstack_health_monitors_update.sync(
    uuid="a1b2c3d4-e5f6-7890-abcd-ef1234567890",
    client=client,
    body=body_data
)

print(response)
  1. Model Source: UpdateHealthMonitorRequest
  2. API Source: openstack_health_monitors_update
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import { openstackHealthMonitorsUpdate } from 'waldur-js-client';

try {
  const response = await openstackHealthMonitorsUpdate({
  auth: "Token YOUR_API_TOKEN",
  path: {
    "uuid": "a1b2c3d4-e5f6-7890-abcd-ef1234567890"
  }
});
  console.log('Success:', response);
} catch (error) {
  console.error('Error:', error);
}
Name Type Required
uuid string (uuid) ✓
Field Type Required Description
name string
delay integer Interval between health checks in seconds
Constraints: default: 5
timeout integer Time in seconds to timeout a health check
Constraints: default: 5
max_retries integer
Constraints: default: 3
max_retries_down integer
Constraints: default: 3

200 -

Field Type Description
url string (uri)
uuid string (uuid)
name string
delay integer Interval between health checks in seconds
timeout integer Time in seconds to timeout a health check
max_retries integer
max_retries_down integer

Update listener

Update an existing listener.

1
2
3
4
http \
  PUT \
  https://api.example.com/api/openstack-listeners/a1b2c3d4-e5f6-7890-abcd-ef1234567890/ \
  Authorization:"Token YOUR_API_TOKEN"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
from waldur_api_client.client import AuthenticatedClient
from waldur_api_client.models.update_listener_request import UpdateListenerRequest # (1)
from waldur_api_client.api.openstack_listeners import openstack_listeners_update # (2)

client = AuthenticatedClient(
    base_url="https://api.example.com", token="YOUR_API_TOKEN"
)

body_data = UpdateListenerRequest()
response = openstack_listeners_update.sync(
    uuid="a1b2c3d4-e5f6-7890-abcd-ef1234567890",
    client=client,
    body=body_data
)

print(response)
  1. Model Source: UpdateListenerRequest
  2. API Source: openstack_listeners_update
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import { openstackListenersUpdate } from 'waldur-js-client';

try {
  const response = await openstackListenersUpdate({
  auth: "Token YOUR_API_TOKEN",
  path: {
    "uuid": "a1b2c3d4-e5f6-7890-abcd-ef1234567890"
  }
});
  console.log('Success:', response);
} catch (error) {
  console.error('Error:', error);
}
Name Type Required
uuid string (uuid) ✓
Field Type Required
name string
default_pool string (uri)

200 -

Field Type
name string
default_pool string (uri)

Update load balancer

Update an existing load balancer.

1
2
3
4
5
http \
  PUT \
  https://api.example.com/api/openstack-loadbalancers/a1b2c3d4-e5f6-7890-abcd-ef1234567890/ \
  Authorization:"Token YOUR_API_TOKEN" \
  name="my-awesome-openstack-loadbalancer"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
from waldur_api_client.client import AuthenticatedClient
from waldur_api_client.models.update_load_balancer_request import UpdateLoadBalancerRequest # (1)
from waldur_api_client.api.openstack_loadbalancers import openstack_loadbalancers_update # (2)

client = AuthenticatedClient(
    base_url="https://api.example.com", token="YOUR_API_TOKEN"
)

body_data = UpdateLoadBalancerRequest(
    name="my-awesome-openstack-loadbalancer"
)
response = openstack_loadbalancers_update.sync(
    uuid="a1b2c3d4-e5f6-7890-abcd-ef1234567890",
    client=client,
    body=body_data
)

print(response)
  1. Model Source: UpdateLoadBalancerRequest
  2. API Source: openstack_loadbalancers_update
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
import { openstackLoadbalancersUpdate } from 'waldur-js-client';

try {
  const response = await openstackLoadbalancersUpdate({
  auth: "Token YOUR_API_TOKEN",
  path: {
    "uuid": "a1b2c3d4-e5f6-7890-abcd-ef1234567890"
  },
  body: {
    "name": "my-awesome-openstack-loadbalancer"
  }
});
  console.log('Success:', response);
} catch (error) {
  console.error('Error:', error);
}
Name Type Required
uuid string (uuid) ✓
Field Type Required
name string ✓

200 -

Field Type
url string (uri)
uuid string (uuid)
name string

Update pool member

Update an existing pool member.

1
2
3
4
http \
  PUT \
  https://api.example.com/api/openstack-pool-members/a1b2c3d4-e5f6-7890-abcd-ef1234567890/ \
  Authorization:"Token YOUR_API_TOKEN"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
from waldur_api_client.client import AuthenticatedClient
from waldur_api_client.models.update_pool_member_request import UpdatePoolMemberRequest # (1)
from waldur_api_client.api.openstack_pool_members import openstack_pool_members_update # (2)

client = AuthenticatedClient(
    base_url="https://api.example.com", token="YOUR_API_TOKEN"
)

body_data = UpdatePoolMemberRequest()
response = openstack_pool_members_update.sync(
    uuid="a1b2c3d4-e5f6-7890-abcd-ef1234567890",
    client=client,
    body=body_data
)

print(response)
  1. Model Source: UpdatePoolMemberRequest
  2. API Source: openstack_pool_members_update
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import { openstackPoolMembersUpdate } from 'waldur-js-client';

try {
  const response = await openstackPoolMembersUpdate({
  auth: "Token YOUR_API_TOKEN",
  path: {
    "uuid": "a1b2c3d4-e5f6-7890-abcd-ef1234567890"
  }
});
  console.log('Success:', response);
} catch (error) {
  console.error('Error:', error);
}
Name Type Required
uuid string (uuid) ✓
Field Type Required
name string
weight integer

200 -

Field Type
url string (uri)
uuid string (uuid)
name string
weight integer

Update pool

Update an existing pool.

1
2
3
4
5
http \
  PUT \
  https://api.example.com/api/openstack-pools/a1b2c3d4-e5f6-7890-abcd-ef1234567890/ \
  Authorization:"Token YOUR_API_TOKEN" \
  name="my-awesome-openstack-pool"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
from waldur_api_client.client import AuthenticatedClient
from waldur_api_client.models.update_pool_request import UpdatePoolRequest # (1)
from waldur_api_client.api.openstack_pools import openstack_pools_update # (2)

client = AuthenticatedClient(
    base_url="https://api.example.com", token="YOUR_API_TOKEN"
)

body_data = UpdatePoolRequest(
    name="my-awesome-openstack-pool"
)
response = openstack_pools_update.sync(
    uuid="a1b2c3d4-e5f6-7890-abcd-ef1234567890",
    client=client,
    body=body_data
)

print(response)
  1. Model Source: UpdatePoolRequest
  2. API Source: openstack_pools_update
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
import { openstackPoolsUpdate } from 'waldur-js-client';

try {
  const response = await openstackPoolsUpdate({
  auth: "Token YOUR_API_TOKEN",
  path: {
    "uuid": "a1b2c3d4-e5f6-7890-abcd-ef1234567890"
  },
  body: {
    "name": "my-awesome-openstack-pool"
  }
});
  console.log('Success:', response);
} catch (error) {
  console.error('Error:', error);
}
Name Type Required
uuid string (uuid) ✓
Field Type Required
name string ✓

200 -

Field Type
url string (uri)
uuid string (uuid)
name string

Partial Update

1
2
3
4
http \
  PATCH \
  https://api.example.com/api/openstack/discovery/123/ \
  Authorization:"Token YOUR_API_TOKEN"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
from waldur_api_client.client import AuthenticatedClient
from waldur_api_client.api.openstack import openstack_discovery_partial_update # (1)

client = AuthenticatedClient(
    base_url="https://api.example.com", token="YOUR_API_TOKEN"
)
response = openstack_discovery_partial_update.sync(
    id=123,
    client=client
)

print(response)
  1. API Source: openstack_discovery_partial_update
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import { openstackDiscoveryPartialUpdate } from 'waldur-js-client';

try {
  const response = await openstackDiscoveryPartialUpdate({
  auth: "Token YOUR_API_TOKEN",
  path: {
    "id": 123
  }
});
  console.log('Success:', response);
} catch (error) {
  console.error('Error:', error);
}
Name Type Required Description
id integer ✓ A unique integer value identifying this Service provider.

200 - No response body

Partially update health monitor

Update specific fields of a health monitor.

1
2
3
4
http \
  PATCH \
  https://api.example.com/api/openstack-health-monitors/a1b2c3d4-e5f6-7890-abcd-ef1234567890/ \
  Authorization:"Token YOUR_API_TOKEN"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
from waldur_api_client.client import AuthenticatedClient
from waldur_api_client.models.patched_update_health_monitor_request import PatchedUpdateHealthMonitorRequest # (1)
from waldur_api_client.api.openstack_health_monitors import openstack_health_monitors_partial_update # (2)

client = AuthenticatedClient(
    base_url="https://api.example.com", token="YOUR_API_TOKEN"
)

body_data = PatchedUpdateHealthMonitorRequest()
response = openstack_health_monitors_partial_update.sync(
    uuid="a1b2c3d4-e5f6-7890-abcd-ef1234567890",
    client=client,
    body=body_data
)

print(response)
  1. Model Source: PatchedUpdateHealthMonitorRequest
  2. API Source: openstack_health_monitors_partial_update
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import { openstackHealthMonitorsPartialUpdate } from 'waldur-js-client';

try {
  const response = await openstackHealthMonitorsPartialUpdate({
  auth: "Token YOUR_API_TOKEN",
  path: {
    "uuid": "a1b2c3d4-e5f6-7890-abcd-ef1234567890"
  }
});
  console.log('Success:', response);
} catch (error) {
  console.error('Error:', error);
}
Name Type Required
uuid string (uuid) ✓
Field Type Required Description
name string
delay integer Interval between health checks in seconds
Constraints: default: 5
timeout integer Time in seconds to timeout a health check
Constraints: default: 5
max_retries integer
Constraints: default: 3
max_retries_down integer
Constraints: default: 3

200 -

Field Type Description
url string (uri)
uuid string (uuid)
name string
delay integer Interval between health checks in seconds
timeout integer Time in seconds to timeout a health check
max_retries integer
max_retries_down integer

Partially update listener

Update specific fields of a listener.

1
2
3
4
http \
  PATCH \
  https://api.example.com/api/openstack-listeners/a1b2c3d4-e5f6-7890-abcd-ef1234567890/ \
  Authorization:"Token YOUR_API_TOKEN"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
from waldur_api_client.client import AuthenticatedClient
from waldur_api_client.models.patched_update_listener_request import PatchedUpdateListenerRequest # (1)
from waldur_api_client.api.openstack_listeners import openstack_listeners_partial_update # (2)

client = AuthenticatedClient(
    base_url="https://api.example.com", token="YOUR_API_TOKEN"
)

body_data = PatchedUpdateListenerRequest()
response = openstack_listeners_partial_update.sync(
    uuid="a1b2c3d4-e5f6-7890-abcd-ef1234567890",
    client=client,
    body=body_data
)

print(response)
  1. Model Source: PatchedUpdateListenerRequest
  2. API Source: openstack_listeners_partial_update
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import { openstackListenersPartialUpdate } from 'waldur-js-client';

try {
  const response = await openstackListenersPartialUpdate({
  auth: "Token YOUR_API_TOKEN",
  path: {
    "uuid": "a1b2c3d4-e5f6-7890-abcd-ef1234567890"
  }
});
  console.log('Success:', response);
} catch (error) {
  console.error('Error:', error);
}
Name Type Required
uuid string (uuid) ✓
Field Type Required
name string
default_pool string (uri)

200 -

Field Type
name string
default_pool string (uri)

Partially update load balancer

Update specific fields of a load balancer.

1
2
3
4
http \
  PATCH \
  https://api.example.com/api/openstack-loadbalancers/a1b2c3d4-e5f6-7890-abcd-ef1234567890/ \
  Authorization:"Token YOUR_API_TOKEN"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
from waldur_api_client.client import AuthenticatedClient
from waldur_api_client.models.patched_update_load_balancer_request import PatchedUpdateLoadBalancerRequest # (1)
from waldur_api_client.api.openstack_loadbalancers import openstack_loadbalancers_partial_update # (2)

client = AuthenticatedClient(
    base_url="https://api.example.com", token="YOUR_API_TOKEN"
)

body_data = PatchedUpdateLoadBalancerRequest()
response = openstack_loadbalancers_partial_update.sync(
    uuid="a1b2c3d4-e5f6-7890-abcd-ef1234567890",
    client=client,
    body=body_data
)

print(response)
  1. Model Source: PatchedUpdateLoadBalancerRequest
  2. API Source: openstack_loadbalancers_partial_update
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import { openstackLoadbalancersPartialUpdate } from 'waldur-js-client';

try {
  const response = await openstackLoadbalancersPartialUpdate({
  auth: "Token YOUR_API_TOKEN",
  path: {
    "uuid": "a1b2c3d4-e5f6-7890-abcd-ef1234567890"
  }
});
  console.log('Success:', response);
} catch (error) {
  console.error('Error:', error);
}
Name Type Required
uuid string (uuid) ✓
Field Type Required
name string

200 -

Field Type
url string (uri)
uuid string (uuid)
name string

Partially update pool member

Update specific fields of a pool member.

1
2
3
4
http \
  PATCH \
  https://api.example.com/api/openstack-pool-members/a1b2c3d4-e5f6-7890-abcd-ef1234567890/ \
  Authorization:"Token YOUR_API_TOKEN"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
from waldur_api_client.client import AuthenticatedClient
from waldur_api_client.models.patched_update_pool_member_request import PatchedUpdatePoolMemberRequest # (1)
from waldur_api_client.api.openstack_pool_members import openstack_pool_members_partial_update # (2)

client = AuthenticatedClient(
    base_url="https://api.example.com", token="YOUR_API_TOKEN"
)

body_data = PatchedUpdatePoolMemberRequest()
response = openstack_pool_members_partial_update.sync(
    uuid="a1b2c3d4-e5f6-7890-abcd-ef1234567890",
    client=client,
    body=body_data
)

print(response)
  1. Model Source: PatchedUpdatePoolMemberRequest
  2. API Source: openstack_pool_members_partial_update
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import { openstackPoolMembersPartialUpdate } from 'waldur-js-client';

try {
  const response = await openstackPoolMembersPartialUpdate({
  auth: "Token YOUR_API_TOKEN",
  path: {
    "uuid": "a1b2c3d4-e5f6-7890-abcd-ef1234567890"
  }
});
  console.log('Success:', response);
} catch (error) {
  console.error('Error:', error);
}
Name Type Required
uuid string (uuid) ✓
Field Type Required
name string
weight integer

200 -

Field Type
url string (uri)
uuid string (uuid)
name string
weight integer

Partially update pool

Update specific fields of a pool.

1
2
3
4
http \
  PATCH \
  https://api.example.com/api/openstack-pools/a1b2c3d4-e5f6-7890-abcd-ef1234567890/ \
  Authorization:"Token YOUR_API_TOKEN"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
from waldur_api_client.client import AuthenticatedClient
from waldur_api_client.models.patched_update_pool_request import PatchedUpdatePoolRequest # (1)
from waldur_api_client.api.openstack_pools import openstack_pools_partial_update # (2)

client = AuthenticatedClient(
    base_url="https://api.example.com", token="YOUR_API_TOKEN"
)

body_data = PatchedUpdatePoolRequest()
response = openstack_pools_partial_update.sync(
    uuid="a1b2c3d4-e5f6-7890-abcd-ef1234567890",
    client=client,
    body=body_data
)

print(response)
  1. Model Source: PatchedUpdatePoolRequest
  2. API Source: openstack_pools_partial_update
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import { openstackPoolsPartialUpdate } from 'waldur-js-client';

try {
  const response = await openstackPoolsPartialUpdate({
  auth: "Token YOUR_API_TOKEN",
  path: {
    "uuid": "a1b2c3d4-e5f6-7890-abcd-ef1234567890"
  }
});
  console.log('Success:', response);
} catch (error) {
  console.error('Error:', error);
}
Name Type Required
uuid string (uuid) ✓
Field Type Required
name string

200 -

Field Type
url string (uri)
uuid string (uuid)
name string

Delete

1
2
3
4
http \
  DELETE \
  https://api.example.com/api/openstack/discovery/123/ \
  Authorization:"Token YOUR_API_TOKEN"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
from waldur_api_client.client import AuthenticatedClient
from waldur_api_client.api.openstack import openstack_discovery_destroy # (1)

client = AuthenticatedClient(
    base_url="https://api.example.com", token="YOUR_API_TOKEN"
)
response = openstack_discovery_destroy.sync(
    id=123,
    client=client
)

print(response)
  1. API Source: openstack_discovery_destroy
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import { openstackDiscoveryDestroy } from 'waldur-js-client';

try {
  const response = await openstackDiscoveryDestroy({
  auth: "Token YOUR_API_TOKEN",
  path: {
    "id": 123
  }
});
  console.log('Success:', response);
} catch (error) {
  console.error('Error:', error);
}
Name Type Required Description
id integer ✓ A unique integer value identifying this Service provider.

204 - No response body

Delete health monitor

Delete a health monitor.

1
2
3
4
http \
  DELETE \
  https://api.example.com/api/openstack-health-monitors/a1b2c3d4-e5f6-7890-abcd-ef1234567890/ \
  Authorization:"Token YOUR_API_TOKEN"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
from waldur_api_client.client import AuthenticatedClient
from waldur_api_client.api.openstack_health_monitors import openstack_health_monitors_destroy # (1)

client = AuthenticatedClient(
    base_url="https://api.example.com", token="YOUR_API_TOKEN"
)
response = openstack_health_monitors_destroy.sync(
    uuid="a1b2c3d4-e5f6-7890-abcd-ef1234567890",
    client=client
)

print(response)
  1. API Source: openstack_health_monitors_destroy
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import { openstackHealthMonitorsDestroy } from 'waldur-js-client';

try {
  const response = await openstackHealthMonitorsDestroy({
  auth: "Token YOUR_API_TOKEN",
  path: {
    "uuid": "a1b2c3d4-e5f6-7890-abcd-ef1234567890"
  }
});
  console.log('Success:', response);
} catch (error) {
  console.error('Error:', error);
}
Name Type Required
uuid string (uuid) ✓

204 - No response body

Delete listener

Delete a listener.

1
2
3
4
http \
  DELETE \
  https://api.example.com/api/openstack-listeners/a1b2c3d4-e5f6-7890-abcd-ef1234567890/ \
  Authorization:"Token YOUR_API_TOKEN"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
from waldur_api_client.client import AuthenticatedClient
from waldur_api_client.api.openstack_listeners import openstack_listeners_destroy # (1)

client = AuthenticatedClient(
    base_url="https://api.example.com", token="YOUR_API_TOKEN"
)
response = openstack_listeners_destroy.sync(
    uuid="a1b2c3d4-e5f6-7890-abcd-ef1234567890",
    client=client
)

print(response)
  1. API Source: openstack_listeners_destroy
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import { openstackListenersDestroy } from 'waldur-js-client';

try {
  const response = await openstackListenersDestroy({
  auth: "Token YOUR_API_TOKEN",
  path: {
    "uuid": "a1b2c3d4-e5f6-7890-abcd-ef1234567890"
  }
});
  console.log('Success:', response);
} catch (error) {
  console.error('Error:', error);
}
Name Type Required
uuid string (uuid) ✓

204 - No response body

Delete load balancer

Delete a load balancer.

1
2
3
4
http \
  DELETE \
  https://api.example.com/api/openstack-loadbalancers/a1b2c3d4-e5f6-7890-abcd-ef1234567890/ \
  Authorization:"Token YOUR_API_TOKEN"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
from waldur_api_client.client import AuthenticatedClient
from waldur_api_client.api.openstack_loadbalancers import openstack_loadbalancers_destroy # (1)

client = AuthenticatedClient(
    base_url="https://api.example.com", token="YOUR_API_TOKEN"
)
response = openstack_loadbalancers_destroy.sync(
    uuid="a1b2c3d4-e5f6-7890-abcd-ef1234567890",
    client=client
)

print(response)
  1. API Source: openstack_loadbalancers_destroy
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import { openstackLoadbalancersDestroy } from 'waldur-js-client';

try {
  const response = await openstackLoadbalancersDestroy({
  auth: "Token YOUR_API_TOKEN",
  path: {
    "uuid": "a1b2c3d4-e5f6-7890-abcd-ef1234567890"
  }
});
  console.log('Success:', response);
} catch (error) {
  console.error('Error:', error);
}
Name Type Required
uuid string (uuid) ✓

204 - No response body

Delete pool member

Delete a pool member.

1
2
3
4
http \
  DELETE \
  https://api.example.com/api/openstack-pool-members/a1b2c3d4-e5f6-7890-abcd-ef1234567890/ \
  Authorization:"Token YOUR_API_TOKEN"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
from waldur_api_client.client import AuthenticatedClient
from waldur_api_client.api.openstack_pool_members import openstack_pool_members_destroy # (1)

client = AuthenticatedClient(
    base_url="https://api.example.com", token="YOUR_API_TOKEN"
)
response = openstack_pool_members_destroy.sync(
    uuid="a1b2c3d4-e5f6-7890-abcd-ef1234567890",
    client=client
)

print(response)
  1. API Source: openstack_pool_members_destroy
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import { openstackPoolMembersDestroy } from 'waldur-js-client';

try {
  const response = await openstackPoolMembersDestroy({
  auth: "Token YOUR_API_TOKEN",
  path: {
    "uuid": "a1b2c3d4-e5f6-7890-abcd-ef1234567890"
  }
});
  console.log('Success:', response);
} catch (error) {
  console.error('Error:', error);
}
Name Type Required
uuid string (uuid) ✓

204 - No response body

Delete pool

Delete a pool.

1
2
3
4
http \
  DELETE \
  https://api.example.com/api/openstack-pools/a1b2c3d4-e5f6-7890-abcd-ef1234567890/ \
  Authorization:"Token YOUR_API_TOKEN"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
from waldur_api_client.client import AuthenticatedClient
from waldur_api_client.api.openstack_pools import openstack_pools_destroy # (1)

client = AuthenticatedClient(
    base_url="https://api.example.com", token="YOUR_API_TOKEN"
)
response = openstack_pools_destroy.sync(
    uuid="a1b2c3d4-e5f6-7890-abcd-ef1234567890",
    client=client
)

print(response)
  1. API Source: openstack_pools_destroy
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import { openstackPoolsDestroy } from 'waldur-js-client';

try {
  const response = await openstackPoolsDestroy({
  auth: "Token YOUR_API_TOKEN",
  path: {
    "uuid": "a1b2c3d4-e5f6-7890-abcd-ef1234567890"
  }
});
  console.log('Success:', response);
} catch (error) {
  console.error('Error:', error);
}
Name Type Required
uuid string (uuid) ✓

204 - No response body