OPENSTACKSDK(1)

📦

version 4.22.0 · 2 versions

4.22.0 · nixpkgs unstable (latest)
4.13.0 · nixos 26.05

, in nixpkgs unstable

NAME 🌸

openstacksdk — openstacksdk 4.22.0

Okay bestie, this is the openstacksdk manual page, and it's split into three sections:

An installation guide
A section for users looking to build applications which make use of OpenStack
A section for those looking to contribute to this project

INSTALLATION ✨

Installation guide 🎀

The OpenStack SDK is available on PyPI at https://pypi.org/project/openstacksdk under the name openstacksdk. To install it, use pip:

$ pip install openstacksdk

To check the installed version you can call the module with:

$ python -m openstack version

FOR USERS 🫶

Using the OpenStack SDK 💅

This section of documentation pertains to those who wish to use this SDK in their own application. If you're looking for documentation on how to contribute to or extend the SDK, refer to the contributor ../contributor section.

For a listing of terms used throughout the SDK, including the names of projects and services supported by it, see the glossary.

User Guides 🧚

These guides walk you through how to make use of the libraries we provide to work with each OpenStack service. If you're looking for a cookbook approach, this is where you'll want to begin.

Getting started 🌈

openstacksdk aims to talk to any OpenStack cloud. To do this, it requires a configuration file. openstacksdk favours clouds.yaml files, but can also use environment variables. The clouds.yaml file should be provided by your cloud provider or deployment tooling. An example:

clouds:
  mordred:
    region_name: Dallas
    auth:
      username: 'mordred'
      password: XXXXXXX
      project_name: 'demo'
      auth_url: 'https://identity.example.com'

More information on configuring openstacksdk can be found in Configuring OpenStack SDK Applications.

Given sufficient configuration, you can use openstacksdk to interact with your cloud. openstacksdk consists of three layers. Most users will make use of the proxy layer. Using the above clouds.yaml, consider listing servers:

import openstack

# Initialize and turn on debug logging
openstack.enable_logging(debug=True)

# Initialize connection
conn = openstack.connect(cloud='mordred')

# List the servers
for server in conn.compute.servers():
    print(server.to_dict())

openstacksdk also contains a higher-level cloud layer based on logical operations:

import openstack

# Initialize and turn on debug logging
openstack.enable_logging(debug=True)

# Initialize connection
conn = openstack.connect(cloud='mordred')

# List the servers
for server in conn.list_servers():
    print(server.to_dict())

The benefit of this layer is mostly seen in more complicated operations that take multiple steps and where the steps vary across providers. For example:

import openstack

# Initialize and turn on debug logging
openstack.enable_logging(debug=True)

# Initialize connection
conn = openstack.connect(cloud='mordred')

# Upload an image to the cloud
image = conn.create_image(
    'ubuntu-trusty', filename='ubuntu-trusty.qcow2', wait=True)

# Find a flavor with at least 512M of RAM
flavor = conn.get_flavor_by_ram(512)

# Boot a server, wait for it to boot, and then do whatever is needed
# to get a public IP address for it.
conn.create_server(
    'my-server', image=image, flavor=flavor, wait=True, auto_ip=True)

Finally, there is the low-level resource layer. This provides support for the basic CRUD operations supported by REST APIs and is the base building block for the other layers. You typically will not need to use this directly:

import openstack
import openstack.config.loader
import openstack.compute.v2.server

# Initialize and turn on debug logging
openstack.enable_logging(debug=True)

# Initialize connection
conn = openstack.connect(cloud='mordred')

# List the servers
for server in openstack.compute.v2.server.Server.list(session=conn.compute):
    print(server.to_dict())

Using os-client-config 🛠️

Configuring OpenStack SDK Applications ⚙️

Environment Variables 💻

openstacksdk honors all of the normal OS_* variables. It does not provide backwards compatibility to service-specific variables such as NOVA_USERNAME.

If you have OpenStack environment variables set, openstacksdk will produce a cloud config object named envvars containing your values from the environment. If you don't like the name envvars, that's okay, you can override it by setting OS_CLOUD_NAME.

Config Files 📁

openstacksdk will look for a file called clouds.yaml in the following locations:

. (the current directory)
$HOME/.config/openstack (Linux) / ~/Library/Application Support/openstack (macOS) / C:\\Users\\USERNAME\\AppData\\Local\\OpenStack\\openstack (Windows)
/etc/openstack (Linux) / /Library/Application Support/openstack (macOS) / C:\\ProgramData\\OpenStack\\openstack (Windows)

The first file found wins.

You can also set the environment variable OS_CLIENT_CONFIG_FILE to an absolute path of a file to look for and that location will be inserted at the front of the file search list.

The keys are all of the keys you'd expect from OS_* except lower case and without the OS prefix. So, region name is set with region_name.

Splitting Secrets 🤫

In some scenarios, such as configuration management controlled environments, it might be easier to have secrets in one file and non-secrets in another. This is fully supported via an optional file secure.yaml which follows all the same location rules as clouds.yaml. It can contain anything you put in clouds.yaml and will take precedence over anything in the clouds.yaml file.

You can also set the environment variable OS_CLIENT_SECURE_FILE to an absolute path of a file to look for and that location will be inserted at the front of the file search list.

Example 🌟

clouds.yaml

clouds:
  mordred:
    region_name: Dallas
    auth:
      username: 'mordred'
      password: XXXXXXX
      project_name: 'demo'
      auth_url: 'https://identity.example.com'
  mtvexx:
    profile: https://vexxhost.com
    region_name: ca-ymq-1
    dns_api_version: 1
  infra:
    profile: rackspace
    auth:
      username: openstackci
      password: XXXXXXXX
      project_id: 610275
    regions:
    - DFW
    - ORD
    - IAD

secure.yaml

clouds:
  mtvexx:
    auth:
      username: mordred@inaugust.com
      password: XXXXXXXXX
      project_name: mordred@inaugust.com

You may note a few things.

Some of the clouds use a profile key and omit things like auth_url. This relies on a feature known as Vendor Profiles, which is described below.
regions can be a list of regions. When you call get_all_clouds, you'll get a cloud config object for each cloud/region combo.
As seen with dns_api_version, any setting that makes sense to be per-service, like service_type or endpoint or api_version can be set by prefixing the setting with the default service type.

Vendor Profiles 🏷️

Vendor profiles are bundled, named sets of default configuration for specific public OpenStack clouds. They exist because different cloud providers make different deployment choices that leak out to end users: different API versions, image formats, whether floating IPs are required, non-standard service types, region lists, and auth_url values. Vendor profiles capture all of this so that you don't have to.

Vendor profiles can be configured using the profile key for a cloud entry, as seen below.

Note: cloud is a deprecated alias for profile. While still supported, its use should be avoided where possible.

Vendor profiles can be provided three ways:

Built-in vendor profiles

openstacksdk bundles vendor profiles for a number of a public cloud providers. These are documented in Vendor Support and can be retrieved using the openstack.config.vendors module:

>>> vendors.profiles()          # list all supported profiles
>>> vendors.get_profile('ovh')  # show defaults for a specific profile

To use one of these built-in vendor profiles, request it by name:

clouds:
  infra:
    profile: ovh
    auth:
      ...

URL-based vendor profiles

You can also request a vendor profile by URL:

clouds:
  infra:
    profile: https://vexxhost.com/
    auth:
      ...

When a URL is provided, openstacksdk will attempt to retrieve a .well-known/openstack/api file. This file will have the same format and be validated against the same schema as an in-tree vendor profile.

Custom vendor profiles (clouds-public.yaml)

Finally, it is possible to provide custom vendor profiles using a clouds-public.yaml file. A clouds-public.yaml file looks very similar to a clouds.yaml / secure.yaml file but is expected to only contain public information (so e.g. no username/password) information. This means they are well suited for things like internal corporate clouds. openstacksdk will search multiple locations for this file, as described for clouds.yaml / secure.yaml above. However, unlike those files, it is not possible to point to a specific file via an environment variable.

public-clouds:
  # The key is the profile name you reference from clouds.yaml via `profile:`
  my-corp-cloud:
    auth:
      auth_url: https://keystone.example.com:5000/v3
    identity_api_version: '3'
    volume_api_version: '3'
    interface: public
    regions:
      - RegionOne
      - RegionTwo

  # A profile can use the {region_name} template, expanded per region
  acme-public:
    auth:
      auth_url: https://{region_name}.acme-cloud.com:5000/v3/
    identity_api_version: '3'
    image_format: raw
    requires_floating_ip: true
    regions:
      - us-east-1
      - eu-west-1

Auth Settings 🎀

okay so bestie, Keystone has auth plugins — which means openstacksdk literally cannot know ahead of time which auth settings you’re gonna need. The default plugin type is password, which is what all things were before plugins came about. To make validation of values possible, every parameter that exists because of your chosen plugin has to go into the auth dict. For password auth, that includes auth_url, username, and password, plus anything related to domains, projects, and trusts. periodt 💅

MFA Support 🫶

MFA support needs a specially prepared configuration file. In this case you use a combo of two different authorization plugins, and each one has its own requirements for the specified parameters. it’s giving very “bring both your IDs” energy 😭

          clouds:
            mfa:
              auth_type: "v3multifactor"
              auth_methods:
                - v3password
                - v3totp
              auth:
                auth_url: https://identity.cloud.com
                username: user
                user_id: uid
                password: XXXXXXXXX
                project_name: project
                user_domain_name: udn
                project_domain_name: pdn

API Settings ✨

These settings get passed to keystoneauth and are common to all services.

api_timeout — a timeout for API requests. This should be a numerical value indicating some amount (or fraction) of seconds, or 0 for no timeout. (optional, defaults to 0)
collect_timing — whether or not to collect per-method timing information for each API call. (optional, defaults to False)

SSL Settings 🔐

When access to a cloud happens over a secure connection, openstacksdk will always verify the SSL cert by default. You can disable that by setting verify to False. If the cert is signed by an unknown CA, you can provide a specific cacert via cacert.

Warning: 🚨 verify will always have precedence over cacert, so when you set a CA cert but disable verify, the cloud cert will never be validated. no cap, it’s just not gonna check it.

Client certs are also configurable. cert is the client cert file location. If the cert key is not included within the client cert file, its file location needs to be set via key.

          # clouds.yaml
          clouds:
            regular-secure-cloud:
              auth:
                auth_url: https://signed.cert.domain:5000
                ...
            unknown-ca-with-client-cert-secure-cloud:
              auth:
                auth_url: https://unknown.ca.but.secure.domain:5000
                ...
              key: /home/myhome/client-cert.key
              cert: /home/myhome/client-cert.crt
              cacert: /home/myhome/ca.crt
            self-signed-insecure-cloud:
              auth:
                auth_url: https://self.signed.cert.domain:5000
                ...
              verify: False

Note: for parity with openstack command-line options, the insecure boolean is also recognised — with the opposite semantics to verify; i.e. True ignores certificate failures. This should be considered deprecated for verify. 🫠

Cache Settings 🍓

Changed in version 1.0.0: Previously, caching was managed exclusively in the cloud layer. Starting in openstacksdk 1.0.0, caching is moved to the proxy layer. As the cloud layer depends on the proxy layer in 1.0.0, this means both layers can benefit from the cache. iconic behavior honestly 👑

Authenticating and accessing resources on a cloud is often expensive. So it’s super common that applications will wish to do some client-side caching of both credentials and cloud resources. To facilitate this, openstacksdk supports caching credentials and resources using the system keyring and dogpile.cache, respectively.

Tip: 💡 it’s important to emphasise that openstacksdk does not actually cache anything itself. Rather, it collects and presents the cache information so that your various applications that are connecting to OpenStack can share a cache should you desire. It is important that your cache backend is correctly configured according to the needs of your application.

Caching is enabled or disabled globally, rather than on a cloud-by-cloud basis. This is done by configuring the cache top-level key. Caching of authentication tokens can be configured using the following settings:

cache.auth — a boolean indicating whether tokens should be cached in the keyring. When enabled, this allows the consequent connections to the same cloud to skip fetching a new token. When the token expires or is invalidated, openstacksdk will automatically establish a new connection. Defaults to false.

For example, to configure caching of authentication tokens:

          cache:
            auth: true

Caching of resources can be configured using the following settings:

cache.expiration_time — the expiration time in seconds for a cache entry. This should be an integer. Defaults to 0.
cache.class — the cache backend to use, which can include any backend supported by dogpile.cache natively as well as backend provided by third-part packages. This should be a string. Defaults to dogpile.cache.memory.
cache.arguments — a mapping of arbitrary arguments to pass into the cache backend. These are backend specific. Keys should correspond to a configuration option for the configured cache backend. Defaults to {}.
cache.expirations — a mapping of resource types to expiration times. The keys should be specified in the same way as the metrics are emitted, by joining meaningful resource URL segments with .. For example, both /servers and /servers/ID should be specified as servers, while /servers/ID/metadata/KEY should be specified as server.metadata. Values should be an expiration time in seconds. A value of -1 indicates that the cache should never expire, while a value of 0 disables caching for the resource. Defaults to {}.

For example, to configure caching with the dogpile.cache.memory backend with a 1 hour expiration:

          cache:
            expiration_time: 3600

To configure caching with the dogpile.cache.memory backend with a 1 hour expiration but only for requests to the OpenStack Compute service’s /servers API:

          cache:
            expirations:
              servers: 3600

To configure caching with the dogpile.cache.pylibmc backend with a 1 hour expiration time and a memcached server running on your localhost:

          cache:
            expiration_time: 3600
            arguments:
              url:
              - 127.0.0.1

To configure caching with the dogpile.cache.pylibmc backend with a 1 hour expiration time, a memcached server running on your localhost, and multiple per-resource cache expiration times:

          cache:
            class: dogpile.cache.pylibmc
            expiration_time: 3600
            arguments:
              url:
                - 127.0.0.1
            expiration:
              server: 5
              flavor: -1
              compute.servers: 5
              compute.flavors: -1
              image.images: 5

Finally, if the cache key is undefined, a null cache is enabled meaning caching is effectively disabled.

Note: 🧠 Non GET requests cause cache invalidation based on the caching key prefix. This means that, for example, a PUT request to /images/ID will invalidate all images cache — list and all individual entries. Moreover it is possible to explicitly pass the skip_cache parameter to the proxy._get function to bypass cache and invalidate what is already there. This is happening automatically in the wait_for_status methods where it is expected that resource will change some of the attributes over the time. Forcing complete cache invalidation can be achieved calling conn._cache.invalidate.

IPv6 🦋

IPv6 is the future, and you should always use it if your cloud supports it and if your local network supports it. Both of those are easily detectable and all friendly software should do the right thing. we love a forward-compatible moment ✨

However, sometimes a cloud API may return IPv6 information that is not useful to a production deployment. For example, the API may provide an IPv6 address for a server, but not provide that to the host instance via metadata (configdrive) or standard IPv6 autoconfiguration methods — i.e. the host either needs to make a bespoke API call, or otherwise statically configure itself. awkward 😭

For such situations, you can set the force_ipv4, or OS_FORCE_IPV4 boolean environment variable. For example:

          clouds:
            mtvexx:
              profile: vexxhost
              auth:
                username: mordred@inaugust.com
                password: XXXXXXXXX
                project_name: mordred@inaugust.com
              region_name: ca-ymq-1
              dns_api_version: 1
            monty:
              profile: fooprovider
              force_ipv4: true
              auth:
                username: mordred@inaugust.com
                password: XXXXXXXXX
                project_name: mordred@inaugust.com
              region_name: RegionFoo

The above snippet will tell client programs to prefer the IPv4 address and leave the public_v6 field of the Server object blank for the fooprovider cloud. You can also set this with a client flag for all clouds:

          client:
            force_ipv4: true

Service-specific Overrides 💅

Service-specific settings, like the Nova service type, are set with the default service type as a prefix. For instance, to set a special service_type for trove (because you’re using Rackspace):

          database_service_type: 'rax:database'

Per-region settings 🌸

Sometimes you have a cloud provider that has config that is common to the cloud, but also with some things you might want to express on a per-region basis. For instance, Internap provides a public and private network specific to the user in each region, and putting the values of those networks into config can make consuming programs more efficient. efficiency queen 👑

To support this, the region list can actually be a list of dicts, and any setting that can be set at the cloud level can be overridden for that region.

          clouds:
            internap:
              profile: internap
              auth:
                password: XXXXXXXXXXXXXXXXX
                username: api-55f9a00fb2619
                project_name: inap-17037
              regions:
              - name: ams01
                values:
                  networks:
                  - name: inap-17037-WAN1654
                    routes_externally: true
                  - name: inap-17037-LAN6745
              - name: nyj01
                values:
                  networks:
                  - name: inap-17037-WAN1654
                    routes_externally: true
                  - name: inap-17037-LAN6745

💅 Setting Precedence

Okay so bestie, some settings are literally redundant — like, project-name and project-id both specify the project, right? So when two redundant settings beef with each other, the _name option in clouds.yaml wins (that's the equivalent -name CLI option and the _NAME environment variable). Slay, name takes it. ✨

Some environment variables or command line flags can override the settings from clouds.yaml. The way that these ones show up and just take over:

--domain-id (OS_DOMAIN_ID)
--domain-name (OS_DOMAIN_NAME)
--user-domain-id (OS_USER_DOMAIN_ID)
--user-domain-name (OS_USER_DOMAIN_NAME)
--project-domain-id (OS_PROJECT_DOMAIN_ID)
--project-domain-name (OS_PROJECT_DOMAIN_NAME)
--auth-token (OS_AUTH_TOKEN)
--project-id (OS_PROJECT_ID)
--project-name (OS_PROJECT_NAME)
--tenant-id (OS_TENANT_ID) (deprecated for --project-id — yeah she's old, moving on 💀)
--tenant-name (OS_TENANT_NAME) (deprecated for --project-name — her too)

Similarly, if one of the above settings is specified in clouds.yaml as part of the auth section as well as the main section, the auth settings get overridden. Like, look at this config section where project is specified multiple times, it's giving "choose your fighter":

clouds:
  mtvexx:
    profile: https://vexxhost.com
    auth:
      username: mordred@inaugust.com
      password: XXXXXXXXX
      project_name: mylessfavoriteproject
      project_id: 0bedab75-898c-4521-a038-0b4b71c41bed
    region_name: ca-ymq-1
    project_name: myfavoriteproject
    project_id: 2acf9403-25e8-479e-a3c6-d67540c424a4

In the above example, the project_id configuration values will be ignored in favor of the project_name configuration values, and the higher-level project will be chosen over the auth-specified project. So the actual project used will be myfavoriteproject. Periodt. 👑

🌸 Examples

auth

Password-based authentication (project-scoped) — the classic, the icon:

example:
    auth:
        auth_url: http://example.com/identity
        password: password
        project_domain_id: default
        project_name: admin
        user_domain_id: default
        username: admin
    region_name: RegionOne

Password-based authentication (domain-scoped):

example:
    auth:
        auth_url: http://example.com/identity
        domain_id: default
        password: password
        username: admin
    region_name: RegionOne

Password-based authentication (trust-scoped):

example-trust:
    auth:
        auth_url: http://example.com/identity
        password: password
        username: admin
        trust_id: 95946f9eef864fdc993079d8fe3e5747
    region_name: RegionOne

Password-based authentication (system-scoped):

example-system:
    auth:
        auth_url: http://example.com/identity
        password: password
        system_scope: all
        username: admin
    region_name: RegionOne

Application credential-based authentication:

example-appcred:
    auth:
        auth_url: http://example.com/identity
        application_credential_id: 9da0a8da3d394d09bf49dfc27014d254
        application_credential_secret: pKfDSvUOFwO2t2_XxCajAFhzCKAVHI7yfqPb6xjshVDnMUHF7ifju8gMdhHTI4Eo56UP_hEc8ssmgA1NNtKMpA
    auth_type: v3applicationcredential
    region_name: RegionOne

Token-based authentication:

example-token:
    auth:
        auth_url: http://example.com/identity
        token: gAAAAABl32ptw2PN6L9JyBeO16PwQU1SrdMUvUz8Eon7LC2PFItdGRWFpOkK0qwH3JkukTuEM5qbYK9ucowRXET1RBMjZlfVpUa8Nz3qjQdzXw7pBKH4w1e4tekvDCOKfn15ZoujBOvdGqgtpW-febVGaW9oJzf6R3WTMDxWz3YRJjmiOBpwcN8
        project_id: 1fd93a4455c74d2ea94b929fc5f0e488
    auth_type: v3token
    region_name: RegionOne

🫶 Note: This is a toy example: by their very definition tokens are short-lived. You are unlikely to store them in a clouds.yaml file. Instead, you would likely pass the TOTP token via the command line (--os-token) or as an environment variable (OS_TOKEN).

TOTP-based authentication:

example-totp:
    auth:
        auth_url: http://example.com/identity
        passcode: password
        project_domain_id: default
        project_name: admin
        user_domain_id: default
        username: admin
    auth_type: v3totp
    region_name: RegionOne

🫶 Note: This is a toy example: by their very definition TOTP tokens are short-lived. You are unlikely to store them in a clouds.yaml file. Instead, you would likely pass the TOTP token via the command line (--os-passcode) or as an environment variable (OS_PASSCODE).

OAuth1-based authentication:

example-oauth:
    auth:
        auth_url: http://example.com/identity
        consumer_key: foo
        consumer_secret: secret
        access_key: bar
        access_secret: secret
    auth_type: v3oauth1
    region_name: RegionOne

🦋 Using openstack.config in an Application

Usage

The simplest and least useful thing you can do is honestly iconic in its uselessness:

python -m openstack.config.loader

Which will print out whatever it finds for your config. If you want to use it from python — which is much more likely what you actually want to do, bestie — things like this:

Get a named cloud:

import openstack.config

cloud_region = openstack.config.OpenStackConfig().get_one(
    'internap', region_name='ams01')
print(cloud_region.name, cloud_region.region, cloud_region.config)

Or, get all of the clouds:

import openstack.config

cloud_regions = openstack.config.OpenStackConfig().get_all()
for cloud_region in cloud_regions:
    print(cloud_region.name, cloud_region.region, cloud_region.config)

argparse

If you're using openstack.config from a program that wants to process command line options, there's a registration function to register the arguments that both openstack.config and keystoneauth know how to deal with — plus a consumption argument. It's giving teamwork, it's giving synergy:

import argparse

import openstack

parser = argparse.ArgumentParser()
cloud = openstack.connect(options=parser)

🌈 Vendor Support

OpenStack presents deployers with many options, some of which can expose differences to end users. openstacksdk tries its best to collect information about various things a user would need to know. The following is a text representation of the vendor related defaults openstacksdk knows about. Ngl it's a whole vibe check of the cloud landscape. 💜

Default Values

These are the default behaviors unless a cloud is configured differently:

Identity uses password authentication
Identity API Version is 2
Image API Version is 2
Volume API Version is 2
Compute API Version is 2.1
Images must be in qcow2 format
Images are uploaded using PUT interface
Public IPv4 is directly routable via DHCP from Neutron
IPv6 is not provided
Floating IPs are not required
Floating IPs are provided by Neutron
Security groups are provided by Neutron
Vendor specific agents are not used

AURO

https://api.auro.io:5000/v2.0

Regions, bestie:

van1 — Vancouver, BC

And the deets:

Public IPv4 is provided via NAT with Neutron Floating IP

Betacloud

https://api-1.betacloud.de:5000

Regions:

betacloud-1 — Karlsruhe, Germany

And the deets:

Identity API Version is 3
Images must be in raw format
Public IPv4 is provided via NAT with Neutron Floating IP
Volume API Version is 3

Binero

https://auth.binero.cloud:5000/v3

Regions:

europe-se-1 — Stockholm, SE

And the deets:

Identity API Version is 3
Volume API Version is 3
Public IPv4 is directly routable via DHCP from Neutron
Public IPv4 is provided via NAT with Neutron Floating IP

Catalyst

https://api.cloud.catalyst.net.nz:5000/v2.0

Regions:

nz-por-1 — Porirua, NZ
nz_wlg_2 — Wellington, NZ

And the deets:

Identity API Version is 3
Compute API Version is 2
Images must be in raw format
Volume API Version is 3

☁️ City Cloud

URL: https://%(region_name)s.citycloud.com:5000/v3/

Regions, bestie:

Buf1 — Buffalo, NY
dx1 — Dubai, UAE
Fra1 — Frankfurt, DE
Kna1 — Karlskrona, SE
Lon1 — London, UK
Sto2 — Stockholm, SE
tky1 — Tokyo, JP

The facts:

Identity API Version is 3
Public IPv4 is provided via NAT with Neutron Floating IP
Volume API Version is 1

🌸 ConoHa

URL: https://identity.%(region_name)s.conoha.io

Regions:

tyo1 — Tokyo, JP
sin1 — Singapore
sjc1 — San Jose, CA

Important note:

Image upload is not supported 🫠

🦋 DreamCompute

URL: https://iad2.dream.io:5000

Region:

RegionOne — Ashburn, VA

The details:

Identity API Version is 3
Images must be in raw format
IPv6 is provided to every server

👑 Open Telekom Cloud

URL: https://iam.%(region_name)s.otc.t-systems.com/v3

Regions:

eu-de — Biere/Magdeburg, DE
eu-nl — Amsterdam, NL

The facts:

Identity API Version is 3
Public IPv4 is provided via NAT with Neutron Floating IP

✨ ELASTX

URL: https://ops.elastx.cloud:5000/v3

Region:

se-sto — Stockholm, SE

The details:

Identity API Version is 3
Public IPv4 is provided via NAT with Neutron Floating IP

🎀 Enter Cloud Suite

URL: https://api.entercloudsuite.com/v2.0

Regions:

nl-ams1 — Amsterdam, NL
it-mil1 — Milan, IT
de-fra1 — Frankfurt, DE

The fact:

Compute API Version is 2

🍓 Fuga

URL: https://identity.api.fuga.io:5000

Region:

cystack — Netherlands

The details:

Identity API Version is 3
Volume API Version is 3

💜 Internap

URL: https://identity.api.cloud.inap.com/v2.0

Regions:

ams01 — Amsterdam, NL
da01 — Dallas, TX
nyj01 — New York, NY
sin01 — Singapore
sjc01 — San Jose, CA

Important note:

Floating IPs are not supported

🌈 Limestone Networks

URL: https://auth.cloud.lstn.net:5000/v3

Regions:

us-dfw-1 — Dallas, TX
us-slc — Salt Lake City, UT

The details:

Identity API Version is 3
Images must be in raw format
IPv6 is provided to every server connected to the Public Internet network

💫 OVH

URL: https://auth.cloud.ovh.net/v3

Regions:

BHS1 — Beauharnois, QC
SBG1 — Strassbourg, FR
GRA1 — Gravelines, FR

The details:

Images may be in raw format. The qcow2 default is also supported
Floating IPs are not supported

⭐ Rackspace

URL: https://identity.api.rackspacecloud.com/v2.0/

Regions:

DFW — Dallas, TX
HKG — Hong Kong
IAD — Washington, D.C.
LON — London, UK
ORD — Chicago, IL
SYD — Sydney, NSW

The full rundown:

Database Service Type is rax:database
Compute Service Name is cloudServersOpenStack
Images must be in vhd format
Images must be uploaded using the Glance Task Interface
Floating IPs are not supported
Public IPv4 is directly routable via static config by Nova
IPv6 is provided to every server
Security groups are not supported
Uploaded Images need properties to not use vendor agent:: :vm_mode: hvm and :xenapi_use_agent: False 💅
Block Storage API Version is 2
The Block Storage API supports version 2 but only version 1 is in the catalog. The Block Storage endpoint is <https:/>/{region_name}.blockstorage.api.rackspacecloud.com/v2/{project_id}
While passwords are recommended for use, API keys do work as well. The rackspaceauth python package must be installed, and then the following can be added to clouds.yaml:

auth:
  username: myusername
  api_key: myapikey
auth_type: rackspace_apikey

🌸 Switch Cloud 🌸

https://identity.compute.cloud.switch.ch/v3

Regions:

zhw — Zurich West, CH
zhc — Zurich Central, CH
Identity API Version is 3
Compute API Version is 2
Volume API Version is 3
Images must be in raw format
Public IPv4 is provided via NAT with Neutron Floating IP
IPv6 is provided to every server

🦋 SWITCHengines 🦋

https://keystone.cloud.switch.ch:5000/v3

Regions:

LS — Lausanne, CH
ZH — Zurich, CH
Identity API Version is 3
Compute API Version is 2
Images must be in raw format
Volume API Version is 3

🎀 Ultimum 🎀

https://console.ultimum-cloud.com:5000/v2.0

Regions:

RegionOne — Prague, CZ
Volume API Version is 1

⭐ UnitedStack ⭐

https://identity.api.ustack.com/v3

Regions:

bj1 — Beijing, CN
gd1 — Guangdong, CN
Identity API Version is 3
Images must be in raw format
Volume API Version is 1

💜 VEXXHOST 💜

http://auth.vexxhost.net

Regions:

ca-ymq-1 — Montreal, QC
sjc1 — Santa Clara, CA
DNS API Version is 1
Identity API Version is 3
Volume API Version is 3

🌈 Zetta 🌈

https://identity.api.zetta.io/v3

Regions:

no-osl1 — Oslo, NO
DNS API Version is 2
Identity API Version is 3

🧚 Network Config 🧚

There are several different qualities that networks in OpenStack might have that might not be able to be automatically inferred from the available metadata. To help users navigate more complex setups, os-client-config allows configuring a list of network metadata.

clouds:
  amazing:
    networks:
    - name: blue
      routes_externally: true
    - name: purple
      routes_externally: true
      default_interface: true
    - name: green
      routes_externally: false
    - name: yellow
      routes_externally: false
      nat_destination: true
    - name: chartreuse
      routes_externally: false
      routes_ipv6_externally: true
    - name: aubergine
      routes_ipv4_externally: false
      routes_ipv6_externally: true

Every entry must have a name field, which can hold either the name or the id of the network.

routes_externally is a boolean field that labels the network as handling north/south traffic off of the cloud. In a public cloud this might be thought of as the "public" network, but in private clouds it's possible it might be an RFC1918 address. In either case, it provides IPs to servers that things not on the cloud can use. This value defaults to false, which indicates only servers on the same network can talk to it.

routes_ipv4_externally and routes_ipv6_externally are boolean fields to help handle routes_externally in the case where a network has a split stack with different values for IPv4 and IPv6. Either entry, if not given, defaults to the value of routes_externally.

default_interface is a boolean field that indicates that the network is the one that programs should use. It defaults to false. An example of needing to use this value is a cloud with two private networks, and where a user is running ansible in one of the servers to talk to other servers on the private network. Because both networks are private, there would otherwise be no way to determine which one should be used for the traffic.

There can only be one default_interface per cloud. 👑

nat_destination is a boolean field that indicates which network floating ips should be attached to. It defaults to false. Normally this can be inferred by looking for a network that has subnets that have a gateway_ip. But it's possible to have more than one network that satisfies that condition, so the user might want to tell programs which one to pick.

There can be only one nat_destination per cloud. 💅

nat_source is a boolean field that indicates which network floating ips should be requested from. It defaults to false. Normally this can be inferred by looking for a network that is attached to a router. But it's possible to have more than one network that satisfies that condition, so the user might want to tell programs which one to pick.

There can be only one nat_source per cloud. periodt 💀

📚 API Reference 📚

class openstack.config.OpenStackConfig(config_files=None,
vendor_files=None, override_defaults=None, force_ipv4=None,
envvar_prefix=None, secure_files=None, pw_func=None,
session_constructor=None, app_name=None, app_version=None,
load_yaml_config=True, load_envvars=True, statsd_host=None,
statsd_port=None, statsd_prefix=None, statsd_config=None,
influxdb_config=None)

config_filename — the filename that configuration was loaded from, if any.
secure_config_filename — the filename that secure configuration was loaded from, if any.
cloud_config — contains the combined loaded configuration.
get_extra_config(key, defaults=None) — Fetch an arbitrary extra chunk of config, laying in defaults.

Parameters:

key (string) — name of the config section to fetch
defaults (dict) — (optional) default values to merge under the found config

register_argparse_arguments(parser, argv, service_keys=None) — Register all of the common argparse options needed.

Given an argparse parser, register the keystoneauth Session arguments, the keystoneauth Auth Plugin Options and os-cloud. Also, peek in the argv to see if all of the auth plugin options should be registered or merely the ones already configured.

Parameters:

argparse.ArgumentParser — parser to attach argparse options to
argv — the arguments provided to the application
service_keys (string) — Service or list of services this argparse should be specialized for, if known. The first item in the list will be used as the default value for service_type (optional)

Raises: exceptions.ConfigException if an invalid auth-type is requested 🫶

auth_config_hook(config) — Allow examination of config values before loading auth plugin.

OpenStackClient will override this to perform additional checks on auth_type.

option_prompt(config, p_opt) — Prompt user for option that requires a value.
magic_fixes(config) — Perform the set of magic argument fixups.
get_one(cloud=None, validate=True, argparse=None, **kwargs) — Retrieve a single CloudRegion and merge additional options

Parameters

cloud (string) — the name of the configuration to load out of clouds.yaml ✨
validate (boolean) — do we validate the config? Set this to False and, like, no auth plugin gets created at all. It's honestly really only useful for testing 🧪
argparse (Namespace) — an argparse Namespace object; it lets you pass argparse options straight in so they get added to the cloud config. Values of None and '' get removed 🫶
region_name — the name of the region of the cloud.
kwargs — additional configuration options.

Returns 💖 openstack.config.cloud_region.CloudRegion

Raises keystoneauth1.exceptions.MissingRequiredOptions when required auth parameters are missing 😭

`get_one_cloud_osc(cloud=None, validate=True, argparse=None, **kwargs)`

Grab a single CloudRegion and merge extra options into it, bestie 🌸

Parameters

cloud (string) — the name of the configuration to load from clouds.yaml ✨
validate (boolean) — do we validate the config? Set it to False and no auth plugin gets created. It's really only useful for testing 🧪
argparse (Namespace) — an argparse Namespace object; lets you pass argparse options directly in so they get added to the cloud config. Values of None and '' will be removed 💅
region_name — the name of the region of the cloud.
kwargs — additional configuration options.

Raises keystoneauth1.exceptions.MissingRequiredOptions on missing required auth parameters 😭

`static set_one_cloud(config_file, cloud, set_config=None)`

Set up one single cloud configuration, no cap 👑

Parameters

config_file (string) — the path to the config file you want to edit. If this file doesn't exist, it literally gets created for you 🎀
cloud (string) — the name of the configuration to save to clouds.yaml
set_config (dict) — the configuration options to be set.

`class openstack.config.cloud_region.CloudRegion(...)`

class openstack.config.cloud_region.CloudRegion(name=None,
region_name=None, config=None, force_ipv4=False, auth_plugin=None,
openstack_config=None, session_constructor=None, app_name=None,
app_version=None, session=None, discovery_cache=None, extra_config=None,
cache_expiration_time=0, cache_expirations=None, cache_path=None,
cache_class='dogpile.cache.null', cache_arguments=None,
password_callback=None, statsd_host=None, statsd_port=None,
statsd_prefix=None, statsd_config=None, influxdb_config=None,
prometheus_config=None, collector_registry=None, cache_auth=False)

The configuration for a Region of an OpenStack Cloud 🦋

A CloudRegion wraps up all the config info you need to connect to every single service in a Region of a Cloud. It's giving "one object to rule them all" energy 👑

Parameters

name — the name of the CloudRegion. If you don't pass one, it gets derived from the hostname of the authentication URL, falling back to app_name if the auth plugin isn't an identity plugin 🧚
region_name — the default region name for all services in this CloudRegion. If both region_name and config['region_name'] are specified, the kwarg wins (precedence, periodt). It can still be overridden for a given ${service} via a ${service}_region_name key in the config dict ✨
config — a dict of configuration values for the CloudRegion and its services. The key for a ${config_option} of a specific ${service} should be ${service}_${config_option}. So like, to configure the endpoint_override for the block_storage service, the config dict should contain:

'block_storage_endpoint_override': 'http://...'

And if you want to provide a default that's used whenever there's no service-specific override? Just use the unprefixed ${config_option} as the service key, like:

'interface': 'public'

force_ipv4 — if True, force the use of IPv4 addresses when connecting to services.
auth_plugin — a keystoneauth1 auth plugin used to authenticate with the cloud.
openstack_config — the OpenStackConfig object that created this CloudRegion, if any.
session_constructor — a callable used to construct the keystoneauth1 Session for this region. Defaults to keystoneauth1.session.Session.
app_name — the name of the application connecting to the cloud. Used to construct the User-Agent header 💅
app_version — the version of the application connecting to the cloud. Used to construct the User-Agent header.
session — an existing authenticated keystoneauth1 Session to use. If you don't pass one, it gets constructed as needed using session_constructor.
discovery_cache — a dict used to cache API version discovery documents, keyed by URL. It's shared across services so you don't make duplicate discovery requests 🎀
extra_config — a dict of additional, arbitrary config sections that don't correspond to a service. You can get to it via get_client_config().
cache_expiration_time — the default time, in seconds, to cache the results of API calls. A value of 0 disables caching 🚫
cache_expirations — a dict mapping resource names to per-resource cache expiration times, in seconds. Overrides cache_expiration_time for those given resources.
cache_path — the filesystem path to use for the cache, if you're using a file-based cache backend.
cache_class — the dogpile.cache backend to use for caching. Defaults to 'dogpile.cache.null', which disables caching.
cache_arguments — a dict of arguments to pass to the dogpile.cache backend.
password_callback — a callable invoked to prompt for a password when one is required but not otherwise available 🙈
statsd_host — DEPRECATED. Use statsd_config instead.
statsd_port — DEPRECATED. Use statsd_config instead.
statsd_prefix — DEPRECATED. Use statsd_config instead.
statsd_config — configuration for reporting API call metrics to statsd 📊
influxdb_config — configuration for reporting API call metrics to InfluxDB. DEPRECATED: InfluxDB support relies on a deprecated library and will be removed in a future release 💀
collector_registry — a prometheus_client CollectorRegistry used to report API call metrics to Prometheus.
cache_auth — if True, cache authentication tokens (using the keyring library) so they can be reused across processes 🔑

property `full_name`

Returns a string that can be used as an identifier 🏷️

It always returns a valid string, bestie. You'll get name and region_name, or just one of the two if only one is set, or else 'unknown'.

`set_session_constructor(session_constructor)`

Sets the Session constructor. That's it, that's the whole vibe 💅

`get_requests_verify_args()`

Returns the verify and cert values for the requests library 🫶

`get_services()`

Returns a list of service types we know something about ✨

`get_endpoint_from_catalog(service_type, interface=None, region_name=None)`

Returns the endpoint for a given service as found in the catalog 📖

If you want values that respect endpoint overrides, go look at endpoint_for() <#openstack.connection.Connection.endpoint_for> instead.

Parameters

service_type — service type of the endpoint you're searching for.
interface — interface of the endpoint you're searching for. Optional; defaults to the configured value for interface for this Connection.
region_name — region name of the endpoint you're searching for. Optional; defaults to the configured value for region_name for this Connection.

Returns the endpoint of the service, or None if it's not found 😭

`get_auth()`

Returns a keystoneauth plugin built from the auth credentials 🔑

`clear_auth_cache()`

Discard any authentication that got cached for this cloud 🧹

Both the copy kept in the keyring and the state the plugin holds in memory get dropped, so that a connection already built from this region can't keep using the credential and write it back when it closes. The next authentication starts from scratch, which — for an interactive plugin — means asking the user again 🙈 Use this when the cached credential is known to be unusable, like after it's been revoked, or when you want a different account.

Unlike loading and storing, this does not require cache.auth to be enabled, and it doesn't need a keyring to be available: the in-memory state gets dropped regardless. A credential cached while caching was on has to be removable once it's been turned off, otherwise the stale entry would just get reused the next time caching is enabled. Periodt 🎀

`insert_user_agent()`

Set sdk information into the user agent of the Session 🦋

⚠️ Warning: this method lives here purely so os-client-config can use it. It's a hook point — that's literally its whole job — so that os-client-config can provide backwards compatibility and still hang out in the User Agent for the people using os-client-config directly. Bestie, if that's not you, keep scrolling. 💅

Normal consumers of the SDK should use app_name and app_version. But if someone else writes a subclass of CloudRegion, it may be desirable. iykyk.

✨ `get_session()`

Returns a keystoneauth session based on the auth credentials. That's it, that's the tweet. 🎀

✨ `get_service_catalog()`

Helper method to grab the service catalog. Lowkey does exactly what it says on the tin.

✨ `get_all_version_data(service_type)`

Retrieve version data for the given service. Obsessed with a method that tells you the truth.

Parameters

service_type — the service to fetch version data for.

Returns

A ~keystoneauth1.discover.VersionData object containing the version data for the requested service. Slay. ✨

✨ `get_session_client(service_type, version=None, constructor=None, **kwargs)`

Return a prepped keystoneauth Adapter for a given service.

This one's for making direct requests calls against a 'mounted' endpoint. So if you do:

client = get_session_client('compute')

then you can do:

client.get('/flavors')

and it will work like you think. No cap. 🫶

✨ `get_session_endpoint(service_type, min_version=None, max_version=None)`

Return the endpoint from config or the catalog.

If a configuration lists an explicit endpoint for a service, return that. Otherwise, fetch the service catalog from the keystone session and return the appropriate endpoint. Iconic behaviour, honestly.

Parameters

service_type — official service type of service

✨ `get_cache_resource_expiration(resource, default=None)`

Get expiration time for a resource.

Parameters

resource — name of the resource type
default — default value to return if not found (optional, defaults to None)

Returns

Expiration time for the resource type as float or default. 🌸

✨ `requires_floating_ip()`

Return whether or not this cloud requires floating ips.

Returns

True or False if known, None if discovery is needed. And if requires_floating_ip isn't configured but the cloud is known to not provide floating ips, it will return False. She's thorough like that. 💀

✨ `get_external_networks()`

Get list of network names for external networks.

✨ `get_external_ipv4_networks()`

Get list of network names for external IPv4 networks.

✨ `get_external_ipv6_networks()`

Get list of network names for external IPv6 networks.

✨ `get_internal_networks()`

Get list of network names for internal networks.

✨ `get_internal_ipv4_networks()`

Get list of network names for internal IPv4 networks.

✨ `get_internal_ipv6_networks()`

Get list of network names for internal IPv6 networks.

✨ `get_default_network()`

Get network used for default interactions. The main character network, if you will. 👑

✨ `get_nat_destination()`

Get network used for NAT destination.

✨ `get_nat_source()`

Get network used for NAT source.

✨ `get_client_config(name=None, defaults=None)`

Get config settings for a named client.

Settings will also be looked for in a section called 'client'. If settings are found in both, they get merged — with the settings from the named section winning over the settings from the client section, and both of them winning over the provided defaults. Hierarchy! We love a clear priority order. 🎀

Parameters

name (string) — name of the config section to look for.
defaults (dict) — default settings to use.

Returns

A dict containing merged settings from the named section, the client section and the defaults. Gorgeous. ✨

🌈 Connect 🌈

Okay so to work with an OpenStack cloud you first need to create a Connection <#openstack.connection.Connection> to it using your credentials. You can create a connection in a number of ways: using a configuration file, environment variables, or explicit keyword arguments, as illustrated below. Pick your fighter. 💅

It is recommended to use Config Files <#config-clouds-yaml> because the same configuration file can be shared across tools and languages. For a comprehensive overview of configuration handling in openstacksdk, see the Using os-client-config <> guide. It's giving "one config to rule them all". 🦋

✨ Create a connection via a configuration file ✨

To create a connection via a configuration file, you need a YAML file called clouds.yaml. A simple clouds.yaml file looks like the following:

clouds:
  mycloud:
    auth:
      auth_url: https://identity.example.com/v3
      username: "my-username"
      password: "secret-password"
      project_name: "my-project"
      user_domain_name: "Default"
      project_domain_name: "Default"
    region_name: "RegionOne"

To create a Connection <#openstack.connection.Connection> instance using this file, use the connect() factory function and pass the name of the cloud configuration:

def create_connection_from_config():
    return openstack.connect(cloud=TEST_CLOUD)

For more details on the format of clouds.yaml, including standard file locations and profile inheritance, refer to Config Files <#config-clouds-yaml>. Literally all the deets are in there. 📁

✨ Command-line options (argparse) ✨

If you're writing a command-line application, connect() can integrate directly with Python's standard argparse library. Bestie, it's seamless.

When you pass an argparse.ArgumentParser instance via the options parameter, openstacksdk registers its standard options (such as --os-cloud) along with all keystoneauth <https://docs.openstack.org/keystoneauth/latest/> authentication and session options (such as --os-auth-url, --os-username, and --insecure). It then parses sys.argv to configure the connection. This lets your application define its own CLI arguments on the parser while letting openstacksdk handle all the OpenStack configuration flags. Chef's kiss. 👑

def create_connection_from_args():
    parser = argparse.ArgumentParser()
    return openstack.connect(options=parser)

✨ Create a connection via environment variables ✨

You can also build a connection from OS_-prefixed environment variables. If you have the standard OpenStack environment variables set — for example, by sourcing an openrc file — you can create a connection without any additional configuration:

import openstack

conn = openstack.connect()

When no cloud name is given, connect() loads its configuration from the environment. For the full list of supported environment variables, refer to Environment Variables <#config-environment-variables>. Env vars my beloved. 🌱

✨ Create a connection via explicit arguments ✨

To create a Connection <#openstack.connection.Connection> instance via explicit keyword arguments, pass the connection parameters directly to connect():

def create_connection(
    auth_url,
    region,
    project_name,
    username,
    password,
    user_domain,
    project_domain,
):
    return openstack.connect(
        auth_url=auth_url,
        project_name=project_name,
        username=username,
        password=password,
        region_name=region,
        user_domain_name=user_domain,
        project_domain_name=project_domain,
        app_name='examples',
        app_version='1.0',
    )

Note: To enable logging, see the Logging <> user guide. 👀

See also: For service-to-service communication requiring service tokens, refer to the Service Tokens <> guide. 🔑

✨ Next ✨

Now that you can create a connection, continue with the User Guides <#user-guides> to work with an OpenStack service. Go off, you've got this. 🫶✨

🌸 Logging 🌸

openstacksdk uses Python Logging. And because openstacksdk is a library, it does not configure logging handlers automatically — it expects that to be the purview of the consuming application. Respect the boundaries, basically. 💅

✨ Simple Usage ✨

For consumers who just want a basic logging setup without thinking about it too deeply, there's a helper method. If you use it, it should be called before any other openstacksdk functionality. Like, before. First thing. No cap. ⭐

openstack.enable_logging(debug=False, http_debug=False, path=None, stream=None, format_stream=False, format_template='%(asctime)s %(levelname)s: %(name)s %(message)s', handlers=None)

Enable logging output.

Helper function to enable logging. This function is available for debugging purposes and for folks doing simple applications who want an easy "just make it work for me". For more complex applications or for those who want more flexibility, the standard library logging package will receive these messages in any handlers you create. 🎀

Parameters

debug (bool) — set this to True to receive debug messages.
http_debug (bool) — set this to True to receive debug messages including HTTP requests and responses. This implies debug=True. Yes, it's a two-for-one. 💀
path (str) — if a path is specified, logging output will be written to that file in addition to sys.stderr. The path is passed to logging.FileHandler, which will append messages to the file (and create it if needed).
stream — one of None or sys.stdout or sys.stderr. If it is None, nothing is logged to a stream. If it isn't None, console output is logged to this stream.
format_stream (bool) — if format_stream is False, the default, apply format_template to path but not to stream outputs. If True, apply format_template to stream outputs as well.
format_template (str) — template to pass to logging.Formatter.

Return type

None — she gives you nothing back and honestly? That's fine. 🌈

import openstack
openstack.enable_logging()

The stream parameter controls where the log messages get written. It defaults to sys.stdout, which means log messages land on STDOUT. You can point it at another output stream, or set it to None to turn off console logging entirely.

The path parameter sets up logging to a file. By default, if path is given and stream is not, logging only goes to path.

You can combine the path and stream parameters to log to both places at the same time.

To log messages to a file called openstack.log and to the console on stdout:

import sys
import openstack

openstack.enable_logging(
    debug=True, path='openstack.log', stream=sys.stdout)

openstack.enable_logging also sets up a few other loggers and squelches some warnings or log messages that are otherwise uninteresting or unactionable by an openstacksdk user.

✨ Advanced Usage ✨

openstacksdk logs to a set of different named loggers.

Most of the logging is set up to log to the root openstack logger. There are additional sub-loggers that are used at times, primarily so that a user can decide to turn on or off a specific type of logging. They are listed below.

openstack.config — issues pertaining to configuration are logged to the openstack.config logger.
openstack.iterate_timeout — when openstacksdk needs to poll a resource, it does so in a loop that waits between iterations and ultimately times out. The openstack.iterate_timeout logger emits messages for each iteration indicating it is waiting and for how long. These can be useful to see for long running tasks so that one can know things are not stuck, but can also be noisy.
openstack.fnmatch — openstacksdk will try to use fnmatch (https://pymotw.com/2/fnmatch/) on given name_or_id arguments. It’s a best effort attempt, so pattern misses are logged to openstack.fnmatch. A user may not be intending to use an fnmatch pattern — such as if they are trying to find an image named Fedora 24 [official], so these messages are logged separately.

🌈 HTTP Tracing 🌈

HTTP interactions are handled by keystoneauth (https://docs.openstack.org/keystoneauth/latest/). If you want to enable HTTP tracing while using openstacksdk and are not using openstack.enable_logging, set the log level of the keystoneauth logger to DEBUG.

For more information see https://docs.openstack.org/keystoneauth/latest/using-sessions.html#logging

🦋 Python Logging 🦋

Python logging is a standard feature of Python and is documented fully in the Python Documentation.

For more information on Python Logging, see https://docs.python.org/3/library/logging.html.

🌸 Statistics reporting 🌸

openstacksdk can report statistics on individual API requests/responses in several different formats.

Note: metrics will be reported only when corresponding client libraries (statsd for 'statsd' reporting, influxdb for influxdb, etc.) are installed. If libraries are not available then reporting will be silently ignored.

💅 statsd 💅

statsd (https://github.com/statsd/statsd) reporting can be configured via configuration entries or environment variables.

A global metrics entry defines defaults for all clouds. Each cloud can specify a metrics section to override variables; this may be useful to separate results reported for each cloud.

metrics:
  statsd:
    host: __statsd_server_host__
    port: __statsd_server_port__
    prefix: __statsd_prefix__ (default 'openstack.api')
clouds:
  a-cloud:
    auth:
     ...
    metrics:
      statsd:
        prefix: 'openstack.api.a-cloud'

If the STATSD_HOST, STATSD_PORT, or STATSD_PREFIX environment variables are set, they will be taken as the default values (and enable statsd reporting if no other configuration is specified).

Alternatively, statsd can be configured programmatically by passing a statsd_config dict to CloudRegion (#openstack.config.cloud_region.CloudRegion):

import openstack.config

config = openstack.config.OpenStackConfig()
cloud = config.get_one_cloud(
    cloud='my-cloud',
    statsd_config={
        'host': 'statsd.example.com',
        'port': 8125,
        'prefix': 'openstack.api.my-cloud',
    },
)

🎀 InfluxDB 🎀

Deprecated since version 4.11.0: InfluxDB support requires the influxdb library, which only supports InfluxDB 1.x and is itself deprecated. InfluxDB support in openstacksdk is therefore also deprecated and will be removed in a future release.

InfluxDB (https://www.influxdata.com/) reporting can be configured via configuration entries.

As with statsd, each cloud can provide its own metrics section to override any global defaults.

metrics:
  influxdb:
    host: __influxdb_server_host__
    port: __influxdb_server_port__
    use_udp: __True|False__
    username: __influxdb_auth_username__
    password: __influxdb_auth_password__
    database: __influxdb_db_name__
    measurement: __influxdb_measurement_name__
    timeout: __infludb_requests_timeout__
clouds:
  ..

InfluxDB reporting allows setting additional tags into the metrics based on the selected cloud.

clouds:
  my_cloud:
    profile: some_profile
    ...
    additional_metric_tags:
      environment: production

👑 Prometheus 👑

Prometheus (https://prometheus.io/) reporting is not configured via configuration entries. Unlike statsd and InfluxDB, Prometheus works on a pull basis. openstacksdk does not run the necessary HTTP service since it is a library. Instead, an application that uses openstacksdk and wants request stats collected should create a CollectorRegistry and pass it via the prometheus_config argument to CloudRegion (#openstack.config.cloud_region.CloudRegion). The application is then responsible for exposing the registry over HTTP.

import prometheus_client
import openstack.config

registry = prometheus_client.CollectorRegistry()

config = openstack.config.OpenStackConfig()
cloud = config.get_one_cloud(
    cloud='my-cloud',
    prometheus_config={
        'collector_registry': registry,
    },
)

# Use the cloud object; metrics will be recorded in the registry.
# Start the HTTP server to expose metrics to Prometheus.
prometheus_client.start_http_server(8000, registry=registry)

💜 Microversions 💜

As openstacksdk rolls out support for consuming microversions, it will do so on a call by call basis as needed. Just like with major versions, openstacksdk should have logic to handle each microversion for a given REST call it makes, with the following rules in mind:

If an activity openstack performs can be done differently or more efficiently with a new microversion, the support should be added to openstack.cloud and to the appropriate Proxy class.
openstacksdk should always attempt to use the latest microversion it is aware of for a given call, unless a microversion removes important data.
Microversion selection should under no circumstances be exposed to the user in python API calls in the Resource layer or the openstack.cloud layer.
Microversion selection is exposed to the user in the REST layer via the microversion argument to each REST call.
A user of the REST layer may set the default microversion by setting {service_type}_default_microversion in clouds.yaml or OS_{service_type|upper}_DEFAULT_MICROVERSION environment variable.

Note: Setting the default microversion in any circumstance other than when using the REST layer is highly discouraged. Both of the higher layers in openstacksdk provide data normalization as well as logic about which REST call to make. Setting the default microversion could change the behavior of the service in question in such a way that openstacksdk does not understand. If there is a feature of a service that needs a microversion and it is not already transparently exposed in openstacksdk, please file a bug.

If a feature is only exposed for a given microversion and cannot be simulated for older clouds without that microversion, it is ok to add it, but a clear error message should be given to the user that the given feature is not available on their cloud. (A message such as "This cloud supports a maximum microversion of XXX for service YYY and this feature only exists on clouds with microversion ZZZ. Please contact your cloud provider for information about when this feature might be available")
When adding a feature that only exists behind a new microversion, every effort should be made to figure out how to provide the same functionality if at all possible, even if doing so is inefficient. If an inefficient workaround is employed, a warning should be provided to the user. (the user’s workaround to skip the inefficient behavior would be to stop using that openstacksdk API call) An example of this is the nova "get me a network" feature. The logic of "get me a network" can be done client-side, albeit less efficiently. Adding support for the "get me a network" feature via nova microversion should also add support for doing the client-side workaround.
If openstacksdk is aware of logic for more than one microversion, it should always attempt to use the latest version available for the service for that call.
Objects returned from openstacksdk should always go through normalization and thus should always conform to openstacksdk’s documented data model. The objects should never look different to the user regardless of the microversion used for the REST call.
If a microversion adds new fields to an object, those fields should be added to openstacksdk’s data model contract for that object and the data should either be filled in by performing additional REST calls if the data is available that way, or the field should have a default value of None which the user can be expected to test for when attempting to use the new value.
Microversion removes fields that are part of the existing data model contract — bestie, be so careful here. Don't use that new microversion for that call unless you're forced to because the old microversion just isn't on the cloud you're talking to. And if the old one genuinely isn't available anymore? Then either go find the data from another source and fill it in, or shove a value of None into the field and document for the user that on some clouds the value may not exist. No silent gaps, okay? 💅
Microversion removes a field and it's straight-up intractable — like, impossible to work around without fundamentally breaking users? Then raise an issue with the service team in question. Hopefully a resolution can be found during the period while clouds still have the old microversion. 🫶
New calls or objects get added — check in with the service team in question about the expected stability of the object. If there are known changes expected in the future — even if they're like a few years off — openstacksdk should take care to not add commitments to its data model for those fields/features. It is ok for openstacksdk to not have something. It's giving restraint, and we love her for it. ✨

Note: openstacksdk does not currently have any sort of "experimental" opt-in API that would allow exposing things to a user that may not be supportable under the normal compatibility contract. If a conflict arises in the future where there is a strong desire for a feature but also a lack of certainty about its stability over time, an experimental API may want to be explored ... but concrete use cases should arise before such a thing is started. 🧚

💫 Service Tokens 💫

Okay so picture this: OpenStack services are talking to each other on behalf of a user — like the Compute service (Nova) calling the Block Storage service (Cinder), or the Networking service (Neutron) — and the whole operation just fails because the user's authentication token expired before the multi-step operation finished. So rude. 😭

To solve this problem, OpenStack supports service tokens. A service token is a secondary token issued to a dedicated service account and transmitted via the X-Service-Token HTTP header alongside the primary user's X-Auth-Token header. Two tokens, one vibe. 👑

When the receiving service (such as Cinder) receives both tokens, its keystonemiddleware pipeline (https://docs.openstack.org/keystonemiddleware/latest/) validates the service token. If the service token is valid, the operation is permitted to proceed even if the user's token has expired — provided the operation was initiated while the user's token was valid. Service tokens also allow target services to verify the identity of the calling service and authorize service-specific roles. Slay. 💅

For a detailed explanation of service users and tokens in OpenStack, see the Keystone documentation on managing service users (https://docs.openstack.org/keystone/latest/admin/manage-services.html).

🌸 Using service tokens with openstacksdk 🌸

openstacksdk relies on keystoneauth (https://docs.openstack.org/keystoneauth/latest/) for HTTP communication and session management. To attach a service token to requests made by an SDK Connection, you configure a keystoneauth1.service_token.ServiceTokenAuthWrapper.

The wrapper combines two distinct authentication plugins:

User Authentication Plugin (user_auth) — provides credentials for the initiating user or the calling service's standard user context (sent in the X-Auth-Token header). 💖
Service Authentication Plugin (service_auth) — provides credentials for the service user account (sent in the X-Service-Token header). 🦋

Once wrapped, the composite auth plugin is passed to a keystoneauth1.session.Session, which is then supplied to the SDK Connection constructor:

from keystoneauth1 import service_token
from keystoneauth1 import session as ks_session
import openstack.connection

auth = service_token.ServiceTokenAuthWrapper(
    user_auth=user_auth,
    service_auth=service_auth,
)
sess = ks_session.Session(auth=auth)
conn = openstack.connection.Connection(session=sess, region_name=region)

🎀 Configuration 🎀

There are two primary mechanisms available for configuring service tokens. Pick your fighter. ⭐

Service user auth with a service token (oslo.config)

In an OpenStack service operational context (such as Nova communicating with Cinder), configuration is typically managed via oslo.config (https://docs.openstack.org/oslo.config/latest/).

The service configuration file defines credentials for both the target service client group (e.g. [cinder]) and the service user group ([service_user]):

[cinder]
auth_type = password
auth_url = https://identity.example.com/identity/v3
project_domain_name = Default
project_name = service
user_domain_name = Default
username = nova
password = secret-nova-password
os_region_name = RegionOne

[service_user]
send_service_user_token = true
auth_type = password
auth_url = https://identity.example.com/identity/v3
project_domain_name = Default
project_name = service
user_domain_name = Default
username = nova
password = secret-nova-password

Both plugins are loaded using keystoneauth1.loading and wrapped together:

from keystoneauth1 import loading as ks_loading
from keystoneauth1 import service_token
from keystoneauth1 import session as ks_session
import openstack.connection
from oslo_config import cfg

CONF = cfg.CONF

# Load target service auth and service token auth
cinder_auth = ks_loading.load_auth_from_conf_options(CONF, 'cinder')
service_auth = ks_loading.load_auth_from_conf_options(CONF, 'service_user')

# Wrap them so both tokens are sent
auth = service_token.ServiceTokenAuthWrapper(
    user_auth=cinder_auth,
    service_auth=service_auth,
)
sess = ks_session.Session(auth=auth)

conn = openstack.connection.Connection(
    session=sess,
    region_name=CONF.cinder.os_region_name,
)

🌈 End-user credentials with a service token 🌈

When an operation is initiated by an end user whose credentials are loaded from a standard clouds.yaml configuration (or an incoming request context), but the application must include a service token from its configuration file, you can combine the two sources. Two sources, one connection — main character energy fr fr. 💜

import os
from keystoneauth1 import loading as ks_loading
from keystoneauth1 import service_token
from keystoneauth1 import session as ks_session
import openstack.config
import openstack.connection
from oslo_config import cfg

CONF = cfg.CONF

# User credentials from clouds.yaml
cloud_config = openstack.config.OpenStackConfig().get_one(
    cloud=os.environ['OS_CLOUD']
)
user_auth = cloud_config.get_auth()

# Service token credentials from service configuration
service_auth = ks_loading.load_auth_from_conf_options(CONF, 'service_user')

auth = service_token.ServiceTokenAuthWrapper(
    user_auth=user_auth,
    service_auth=service_auth,
)
sess = ks_session.Session(auth=auth)

conn = openstack.connection.Connection(
    session=sess,
    region_name=CONF.cinder.os_region_name,
)

🌟 Example 🌟

A full runnable script demonstrating this pattern against Cinder's list-volume-types endpoint is available in the repository at examples/advanced/service_tokens.py:

#!/usr/bin/env python3
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.

"""Connect to an OpenStack cloud using service tokens.

Reads an oslo.config configuration file (defaulting to /tmp/service.conf, or
specified via --config-file) containing [cinder] and [service_user] sections.

Demonstrates sending a service token alongside the user token:
  X-Auth-Token: <cinder auth token>
  X-Service-Token: <nova service token>

Run with mitmweb/mitmproxy to inspect the outgoing headers::

    export HTTP_PROXY=http://127.0.0.1:8080
    python examples/advanced/service_tokens.py
"""

import sys

from keystoneauth1 import loading as ks_loading
from keystoneauth1 import service_token
from keystoneauth1 import session as ks_session
from oslo_config import cfg

import openstack.connection

CONF = cfg.ConfigOpts()

def _register_opts() -> None:
    # Register options for the target service client group ([cinder])
    cinder_group = cfg.OptGroup('cinder', title='Cinder Options')
    CONF.register_group(cinder_group)
    CONF.register_opts(
        [cfg.StrOpt('os_region_name', default='RegionOne')],
        group='cinder',
    )
    ks_loading.register_session_conf_options(CONF, 'cinder')
    ks_loading.register_auth_conf_options(CONF, 'cinder')

    # Register options for the service user token group ([service_user])
    service_user_group = cfg.OptGroup(
        'service_user', title='Service User Options'
    )
    CONF.register_group(service_user_group)
    CONF.register_opts(
        [cfg.BoolOpt('send_service_user_token', default=False)],
        group='service_user',
    )
    ks_loading.register_session_conf_options(CONF, 'service_user')
    ks_loading.register_auth_conf_options(CONF, 'service_user')

def main() -> None:
    _register_opts()
    CONF(sys.argv[1:], default_config_files=['/tmp/service.conf'])

    # Load auth plugins from configuration
    cinder_auth = ks_loading.load_auth_from_conf_options(CONF, 'cinder')
    service_auth = ks_loading.load_auth_from_conf_options(CONF, 'service_user')

    # Wrap auth plugins so both X-Auth-Token and X-Service-Token are sent
    auth = service_token.ServiceTokenAuthWrapper(
        user_auth=cinder_auth, service_auth=service_auth
    )
    sess = ks_session.Session(auth=auth)

    conn = openstack.connection.Connection(
        session=sess, region_name=CONF.cinder.os_region_name
    )

    print('Listing volume types...')
    try:
        vtypes = list(conn.block_storage.types())
        print(f'Found {len(vtypes)} volume type(s):')
        for vt in vtypes:
            print(f'  - {vt.name} ({vt.id})')
    except Exception as exc:
        print(f'ERROR: {exc}')

if __name__ == '__main__':
    main()

And bestie, if you wanna actually see what's flying out on the wire — like the X-Auth-Token and X-Service-Token headers themselves — you can test this locally with an HTTP proxy (such as mitmproxy) to inspect them 👀:

export HTTP_PROXY=http://127.0.0.1:8080
python examples/advanced/service_tokens.py

🌈 Using OpenStack Baremetal 🌈

Before working with the Bare Metal service, you'll need to create a connection to your OpenStack cloud by following the Connect user guide. That's what hands you the conn variable used in the examples below 🫶.

🎀 Table of Contents 🎀

CRUD operations
- List Nodes
Provisioning operations
- Manage and inspect Node
- Provide Node

The primary resource of the Bare Metal service is the node. Below are a few usage examples — for a reference to all the available methods, see the Baremetal API reference 💅.

🌸 CRUD operations 🌸

⭐ List Nodes ⭐

A node is a bare metal machine. That's it, that's the whole vibe 🖥️.

def list_nodes(conn):
    print("List Nodes:")

    for node in conn.baremetal.nodes():
        print(node)

Full example: baremetal resource list — http://opendev.org/openstack/openstacksdk/src/branch/master/examples/baremetal/list.py

🦋 Provisioning operations 🦋

Provisioning actions are the main way to manipulate the nodes. See the Bare Metal service states documentation at https://docs.openstack.org/ironic/latest/contributor/states.html for details — it's giving essential reading, ngl 📖.

💜 Manage and inspect Node 💜

Managing a node in the enroll provision state validates the management (IPMI, Redfish, etc) credentials and moves the node to the manageable state. Managing a node in the available state moves it to the manageable state. And in that state, extra actions become available — things like configuring RAID or inspecting 🔧.

Inspecting a node detects its properties by either talking to its BMC or by booting a special ramdisk. Either way she's gathering intel ✨.

def manage_and_inspect_node(conn, uuid):
    node = conn.baremetal.find_node(uuid)
    print('Before:', node.provision_state)
    conn.baremetal.set_node_provision_state(node, 'manage')
    conn.baremetal.wait_for_nodes_provision_state([node], 'manageable')
    conn.baremetal.set_node_provision_state(node, 'inspect')
    res = conn.baremetal.wait_for_nodes_provision_state([node], 'manageable')
    print('After:', res[0].provision_state)

Full example: baremetal provisioning — http://opendev.org/openstack/openstacksdk/src/branch/master/examples/baremetal/provisioning.py

🍓 Provide Node 🍓

Providing a node in the manageable provision state makes it available for deployment. Boom, she's ready 👑.

def provide_node(conn, uuid):
    node = conn.baremetal.find_node(uuid)
    print('Before:', node.provision_state)
    conn.baremetal.set_node_provision_state(node, 'provide')
    res = conn.baremetal.wait_for_nodes_provision_state([node], 'available')
    print('After:', res[0].provision_state)

Full example: baremetal provisioning — http://opendev.org/openstack/openstacksdk/src/branch/master/examples/baremetal/provisioning.py

🧚 Using OpenStack Block Storage 🧚

Before working with the Block Storage service, you'll need to create a connection to your OpenStack cloud by following the Connect user guide. This will give you the conn variable used in the examples below 💖.

✨ Table of Contents ✨

Working with Volumes
Working with Snapshots and Backups
Working with Volume Types

The Block Storage service manages volumes and the snapshots, backups and volume types associated with them. The examples below show a representative subset of what's possible — for the complete set of operations, see the Block Storage proxy reference 💅. (Yes, there's a whole reference, go off.)

🌈 Working with Volumes 🌈

To list the existing volumes, use the volumes() method, which returns a generator of Volume objects:

>>> for volume in conn.block_storage.volumes():
...     print(volume.name, volume.status)

To create a volume, use the create_volume() method:

>>> volume = conn.block_storage.create_volume(name='my-volume', size=10)

To retrieve or delete a volume, use the get_volume() and delete_volume() methods. Each accepts either a volume ID or a Volume instance — flexible, we love that 🫶:

>>> volume = conn.block_storage.get_volume(volume.id)
>>> conn.block_storage.delete_volume(volume)

🦋 Working with Snapshots and Backups 🦋

A snapshot captures the state of a volume at a point in time. Create one with create_snapshot(), list them with snapshots(), and remove them with delete_snapshot() — it's giving time capsule energy ⏳:

>>> snapshot = conn.block_storage.create_snapshot(volume_id=volume.id)
>>> for snapshot in conn.block_storage.snapshots():
...     print(snapshot.name)

Backups are managed in the same way through the corresponding backups, create_backup and delete_backup methods. Same vibe, different noun 💾.

🎀 Working with Volume Types 🎀

Volume types describe the capabilities of the storage backing a volume. List the available types with types():

>>> for volume_type in conn.block_storage.types():
...     print(volume_type.name)

👑 Using OpenStack Clustering 👑

Before working with the Clustering service, you'll need to create a connection to your OpenStack cloud by following the Connect user guide. This will give you the conn variable used by all examples in this guide 💖.

The primary abstractions/resources of the Clustering service are:

💜 Working with Profile Types 💜

A profile is a template used to create and manage nodes, i.e. objects exposed by other OpenStack services. A profile encodes the information needed for node creation in a property named spec. It's like a little recipe 🧑‍🍳.

⭐ List Profile Types ⭐

To examine the known profile types:

def list_profile_types(conn):
    print("List Profile Types:")

    for pt in conn.clustering.profile_types():
        print(pt.to_dict())

Full example: manage profile type — https://opendev.org/openstack/openstacksdk/src/branch/master/examples/clustering/profile_type.py

🌸 Get Profile Type 🌸

To get the details about a profile type, you need to provide the name of it:

def get_profile_type(conn):
    print("Get Profile Type:")

    pt = conn.clustering.get_profile_type('os.nova.server-1.0')

    print(pt.to_dict())

Full example: manage profile type — https://opendev.org/openstack/openstacksdk/src/branch/master/examples/clustering/profile_type.py

🌈 Managing Profiles 🌈

A profile type can be treated as the meta-type of a Profile object. A registry of profile types is built when the Cluster service starts. When creating a Profile object, you will indicate the profile type used in its spec property ✨.

🍓 List Profiles 🍓

To examine the list of profiles:

def list_profiles(conn):
    print("List Profiles:")

    for profile in conn.clustering.profiles():
        print(profile.to_dict())

    for profile in conn.clustering.profiles(sort='name:asc'):
        print(profile.to_dict())

When listing profiles, you can specify the sorting option using the sort parameter, and you can do pagination using the limit and marker parameters. Slay, pagination 💅.

Full example: manage profile — https://opendev.org/openstack/openstacksdk/src/branch/master/examples/clustering/profile.py

🧚 Create Profile 🧚

When creating a profile, you will provide a dictionary with keys and values specified according to the profile type referenced:

def create_profile(conn):
    print("Create Profile:")

    spec = {
        'profile': 'os.nova.server',
        'version': 1.0,
        'name': 'os_server',
        'properties': {
            'name': SERVER_NAME,
            'flavor': FLAVOR_NAME,
            'image': IMAGE_NAME,
            'networks': {'network': NETWORK_NAME},
        },
    }

    profile = conn.clustering.create_profile(spec)
    print(profile.to_dict())

Optionally, you can specify a metadata keyword argument that contains some key-value pairs to be associated with the profile 🏷️.

Full example: manage profile — https://opendev.org/openstack/openstacksdk/src/branch/master/examples/clustering/profile.py

🔥 Find Profile 🔥

To find a profile based on its name or ID:

def find_profile(conn):
    print("Find Profile:")

    profile = conn.clustering.find_profile('os_server')
    print(profile.to_dict())

⚠️ Heads up bestie: the Cluster service doesn't allow updating the spec of a profile. The only way to achieve that is to create a new profile. No cap, that's the rule.

Full example: manage profile — https://opendev.org/openstack/openstacksdk/src/branch/master/examples/clustering/profile.py

💖 Get Profile 💖

To get a profile based on its name or ID:

def get_profile(conn):
    print("Get Profile:")

    profile = conn.clustering.get_profile('os_server')
    print(profile.to_dict())

Full example: manage profile — https://opendev.org/openstack/openstacksdk/src/branch/master/examples/clustering/profile.py

🌟 Update Profile 🌟

After a profile is created, most of its properties are immutable. Still, you can update a profile's name and/or metadata — small mercies 🫶.

def update_profile(conn):
    print("Update Profile:")

    profile = conn.clustering.update_profile('os_server', name='old_server')
    print(profile.to_dict())

⚠️ Again for the people in the back: the Cluster service doesn't allow updating the spec of a profile. The only way to achieve that is to create a new profile.

Full example: manage profile — https://opendev.org/openstack/openstacksdk/src/branch/master/examples/clustering/profile.py

🎀 Delete Profile 🎀

A profile can be deleted after creation, provided that it is not referenced by any active clusters or nodes. If you attempt to delete a profile that is still in use, you will get an error message 😭. Choose wisely.

def delete_profile(conn):
    print("Delete Profile:")

    conn.clustering.delete_profile('os_server')

    print("Profile deleted.")

💅 Managing Clusters 💅

Clusters are first-class citizens in Senlin service design. A cluster is defined as a collection of homogeneous objects. The "homogeneous" here means that the objects managed (aka. Nodes) have to be instantiated from the same "profile type" — same template, same energy 👯‍♀️.

🌈 List Clusters 🌈

To examine the list of receivers:

def list_cluster(conn):
    print("List clusters:")

    for cluster in conn.clustering.clusters():
        print(cluster.to_dict())

    for cluster in conn.clustering.clusters(sort='name:asc'):
        print(cluster.to_dict())

When you're listing clusters, you can pick the sorting with the sort parameter, and you can do pagination using the limit and marker parameters. 🎀

Full example: manage cluster <https://opendev.org/openstack/openstacksdk/src/branch/master/examples/clustering/cluster.py>

💖 Create Cluster

When you create a cluster, you hand over a dictionary with keys and values that match whatever cluster type you're referencing. Easy.

def create_cluster(conn):
    print("Create cluster:")

    spec = {
        "name": CLUSTER_NAME,
        "profile_id": PROFILE_ID,
        "min_size": 0,
        "max_size": -1,
        "desired_capacity": 1,
    }

    cluster = conn.clustering.create_cluster(**spec)
    print(cluster.to_dict())

Optionally, you can specify a metadata keyword argument — it holds some key-value pairs to be associated with the cluster. ✨

Full example: manage cluster <https://opendev.org/openstack/openstacksdk/src/branch/master/examples/clustering/cluster.py>

🌸 Get Cluster

Grab a cluster by its name or ID, like:

def get_cluster(conn):
    print("Get cluster:")

    cluster = conn.clustering.get_cluster(CLUSTER_ID)
    print(cluster.to_dict())

Full example: manage cluster <https://opendev.org/openstack/openstacksdk/src/branch/master/examples/clustering/cluster.py>

🦋 Find Cluster

Same deal for finding — name or ID, your call:

def find_cluster(conn):
    print("Find cluster:")

    cluster = conn.clustering.find_cluster(CLUSTER_ID)
    print(cluster.to_dict())

Full example: manage cluster <https://opendev.org/openstack/openstacksdk/src/branch/master/examples/clustering/cluster.py>

💅 Update Cluster

Okay so once a cluster exists, most of its properties are immutable — like, locked in, no take-backs. But you can still update a cluster's name and/or params. 👑

def update_cluster(conn):
    print("Update cluster:")

    spec = {
        "name": "Test_Cluster001",
        "profile_id": "c0e3a680-e270-4eb8-9361-e5c9503fba0a",
        "profile_only": True,
    }
    cluster = conn.clustering.update_cluster(CLUSTER_ID, **spec)
    print(cluster.to_dict())

Full example: manage cluster <https://opendev.org/openstack/openstacksdk/src/branch/master/examples/clustering/cluster.py>

🎀 Delete Cluster

A cluster can be deleted after it's been created. And heads up — when there are nodes in the cluster, the Senlin engine launches a whole process to delete all the nodes from the cluster and destroy them before it deletes the cluster object itself. She does a full cleanup first, respect. 😭

def delete_cluster(conn):
    print("Delete cluster:")

    conn.clustering.delete_cluster(CLUSTER_ID)
    print("Cluster deleted.")

    # cluster support force delete
    conn.clustering.delete_cluster(CLUSTER_ID, False, True)
    print("Cluster deleted")

🌈 Add Nodes to Cluster

Drop some existing nodes into the cluster you specified:

def add_nodes_to_cluster(conn):
    print("Add nodes to cluster:")

    node_ids = [NODE_ID]
    res = conn.clustering.add_nodes_to_cluster(CLUSTER_ID, node_ids)
    print(res)

🍓 Remove Nodes from Cluster

Yeet nodes out of the specified cluster:

def remove_nodes_from_cluster(conn):
    print("Remove nodes from a cluster:")

    node_ids = [NODE_ID]
    res = conn.clustering.remove_nodes_from_cluster(CLUSTER_ID, node_ids)
    print(res)

🔥 Replace Nodes in Cluster

Swap out some existing nodes in the specified cluster for new ones:

def replace_nodes_in_cluster(conn):
    print("Replace the nodes in a cluster with specified nodes:")

    old_node = NODE_ID
    new_node = "cd803d4a-015d-4223-b15f-db29bad3146c"
    spec = {old_node: new_node}
    res = conn.clustering.replace_nodes_in_cluster(CLUSTER_ID, **spec)
    print(res)

💜 Cluster Scale Out

Inflate the size of a cluster. Bigger! 🎈

def scale_out_cluster(conn):
    print("Inflate the size of a cluster:")

    res = conn.clustering.scale_out_cluster(CLUSTER_ID, 1)
    print(res)

🧚 Cluster Scale In

Shrink the size of a cluster. Smaller! 🫧

def scale_out_cluster(conn):
    print("Inflate the size of a cluster:")

    res = conn.clustering.scale_out_cluster(CLUSTER_ID, 1)
    print(res)

Ngl bestie, the original page literally prints this exact same scale_out_cluster example under "Scale In" too — I'm not making it up, I'm just faithfully passing the copy-paste along. 💀

⭐ Cluster Resize

Resize of cluster. You get the whole spec treatment here:

def resize_cluster(conn):
    print("Resize of cluster:")

    spec = {
        'min_size': 1,
        'max_size': 6,
        'adjustment_type': 'EXACT_CAPACITY',
        'number': 2,
    }
    res = conn.clustering.resize_cluster(CLUSTER_ID, **spec)
    print(res)

👑 Attach Policy to Cluster

Once a policy is attached (bound) to a cluster, it gets enforced whenever related actions are performed on that cluster — unless the policy is (temporarily) disabled on the cluster. The way it just kicks in automatically, iconic.

def attach_policy_to_cluster(conn):
    print("Attach policy to a cluster:")

    spec = {'enabled': True}
    res = conn.clustering.attach_policy_to_cluster(
        CLUSTER_ID, POLICY_ID, **spec
    )
    print(res)

🫶 Detach Policy from Cluster

Once a policy is attached to a cluster, it can be detached from the cluster whenever the user requests it. No strings. ✨

def detach_policy_from_cluster(conn):
    print("Detach a policy from a cluster:")

    res = conn.clustering.detach_policy_from_cluster(CLUSTER_ID, POLICY_ID)
    print(res)

🌸 Cluster Check

Check the cluster's health status — cluster members can be checked too. Glow-up check for the whole squad. 💖

def check_cluster(conn):
    print("Check cluster:")

    res = conn.clustering.check_cluster(CLUSTER_ID)
    print(res)

🦋 Cluster Recover

To restore a specified cluster, the members in the cluster get checked:

def recover_cluster(conn):
    print("Recover cluster:")

    spec = {'check': True}
    res = conn.clustering.recover_cluster(CLUSTER_ID, **spec)
    print(res)

🎀 Managing Nodes

A node is a logical object managed by the Senlin service. Real talk: a node can be a member of at most one cluster at any given time. A node can also be an orphan node — which just means it doesn't belong to any clusters. Solo era. 🙈

💜 List Nodes

To examine the list of Nodes:

def list_nodes(conn):
    print("List Nodes:")

    for node in conn.clustering.nodes():
        print(node.to_dict())
    for node in conn.clustering.nodes(sort='asc:name'):
        print(node.to_dict())

When you're listing nodes, you can specify the sorting option using the sort parameter, and you can do pagination using the limit and marker parameters.

Full example: manage node <https://opendev.org/openstack/openstacksdk/src/branch/master/examples/clustering/node.py>

🌈 Create Node

When creating a node, you provide a dictionary with keys and values according to the node type you referenced:

def create_node(conn):
    print("Create Node:")

    spec = {
        'name': NODE_NAME,
        'profile_id': PROFILE_ID,
    }
    node = conn.clustering.create_node(**spec)
    print(node.to_dict())

Optionally, you can specify a metadata keyword argument that contains some key-value pairs to be associated with the node. 🎀

Full example: manage node <https://opendev.org/openstack/openstacksdk/src/branch/master/examples/clustering/node.py>

🍓 Get Node

To get a node based on its name or ID:

def get_node(conn):
    print("Get Node:")

    node = conn.clustering.get_node(NODE_ID)
    print(node.to_dict())

Full example: manage node <https://opendev.org/openstack/openstacksdk/src/branch/master/examples/clustering/node.py>

⭐ Find Node

To find a node based on its name or ID:

def find_node(conn):
    print("Find Node:")

    node = conn.clustering.find_node(NODE_ID)
    print(node.to_dict())

Full example: manage node <https://opendev.org/openstack/openstacksdk/src/branch/master/examples/clustering/node.py>

🔥 Update Node

After a node is created, most of its properties are immutable. Still, you can update a node's name and/or params. 💅

def update_node(conn):
    print("Update Node:")

    spec = {
        'name': 'Test_Node01',
        'profile_id': 'c0e3a680-e270-4eb8-9361-e5c9503fba0b',
    }

    node = conn.clustering.update_node(NODE_ID, **spec)
    print(node.to_dict())

Full example: manage node <https://opendev.org/openstack/openstacksdk/src/branch/master/examples/clustering/node.py>

💀 Delete Node

A node can be deleted after creation — provided that it isn't referenced by any active clusters. Try to delete a node that's still in use and you'll get an error message, bestie. That's the vibe check saying no.

def delete_node(conn):
    print("Delete Node:")

    conn.clustering.delete_node(NODE_ID)
    print("Node deleted.")
    # node support force delete
    conn.clustering.delete_node(NODE_ID, False, True)
    print("Node deleted")

Full example: manage node <https://opendev.org/openstack/openstacksdk/src/branch/master/examples/clustering/node.py>

🫶 Check Node

If the underlying physical resource is not healthy, the node gets set to ERROR status. Not the cute kind of error. 😭

def check_node(conn):
    print("Check Node:")

    node = conn.clustering.check_node(NODE_ID)
    print(node)

Full example: manage node <https://opendev.org/openstack/openstacksdk/src/branch/master/examples/clustering/node.py>

🧚 Recover Node

To restore a specified node:

def recover_node(conn):
    print("Recover Node:")

    spec = {'check': True}
    node = conn.clustering.recover_node(NODE_ID, **spec)
    print(node)

👑 Working with Policy Types

A policy is a template that encodes the information needed for specifying the rules that are checked/enforced before/after certain actions are performed on a cluster. Those rules are encoded in a property named spec. So spec is the main character here, fr fr.

🌸 List Policy Types

To examine the known policy types:

def list_policy_types(conn):
    print("List Policy Types:")

    for pt in conn.clustering.policy_types():
        print(pt.to_dict())

Full example: manage policy type <https://opendev.org/openstack/openstacksdk/src/branch/master/examples/clustering/policy_type.py>

🦋 Get Policy Type

To retrieve the details about a policy type, you need to provide its name:

def get_policy_type(conn):
    print("Get Policy Type:")

    pt = conn.clustering.get_policy_type('senlin.policy.deletion-1.0')

    print(pt.to_dict())

Full example: manage policy type <https://opendev.org/openstack/openstacksdk/src/branch/master/examples/clustering/policy_type.py>

💅 Managing Policies

Okay so listen — a policy type is basically the meta-type of a Policy object, right? Like the blueprint for the blueprint. ✨ A whole registry of these policy types gets built the moment the Cluster service starts up. And when you're creating a Policy object, you tell it which policy type you're using inside its spec property. That's the whole vibe.

🎀 List Policies

Wanna see all the policies? Say less:

def list_policies(conn):
    print("List Policies:")

    for policy in conn.clustering.policies():
        print(policy.to_dict())

    for policy in conn.clustering.policies(sort='name:asc'):
        print(policy.to_dict())

When you're listing policies you can totally set the sorting with the sort parameter, and pagination is yours via the limit and marker parameters. Slay.

Full example: manage policy <https://opendev.org/openstack/openstacksdk/src/branch/master/examples/clustering/policy.py>

🌸 Create Policy

When you're creating a policy you hand over a dictionary of keys and values that line up with whatever policy type you referenced. Like this:

def create_policy(conn):
    print("Create Policy:")
    attrs = {
        'name': 'dp01',
        'spec': {
            'policy': 'senlin.policy.deletion',
            'version': 1.0,
            'properties': {
                'criteria': 'oldest_first',
                'destroy_after_deletion': True,
            },
        },
    }

    policy = conn.clustering.create_policy(attrs)
    print(policy.to_dict())

Optionally — and this is a cute little extra — you can pass a metadata keyword argument stuffed with key-value pairs to associate with the policy. 🫶

Full example: manage policy <https://opendev.org/openstack/openstacksdk/src/branch/master/examples/clustering/policy.py>

🦋 Find Policy

Wanna find a policy by its name or ID? Here ya go:

def find_policy(conn):
    print("Find Policy:")

    policy = conn.clustering.find_policy('dp01')
    print(policy.to_dict())

Full example: manage policy <https://opendev.org/openstack/openstacksdk/src/branch/master/examples/clustering/policy.py>

💖 Get Policy

Getting a policy based on its name or ID, bestie:

def get_policy(conn):
    print("Get Policy:")

    policy = conn.clustering.get_policy('dp01')
    print(policy.to_dict())

Full example: manage policy <https://opendev.org/openstack/openstacksdk/src/branch/master/examples/clustering/policy.py>

⭐ Update Policy

So once a policy exists, most of its properties are immutable — like, locked in, no take-backs. But you can still update a policy's name and/or metadata:

def update_policy(conn):
    print("Update Policy:")

    policy = conn.clustering.update_policy('dp01', name='dp02')
    print(policy.to_dict())

⚠️ Heads up: the Cluster service does not allow updating the spec of a policy. The only way to pull that off is to create a brand new policy. Periodt.

Full example: manage policy <https://opendev.org/openstack/openstacksdk/src/branch/master/examples/clustering/policy.py>

💀 Delete Policy

A policy can be deleted after it's created — provided it's not referenced by any active clusters or nodes. Try to delete one that's still in use and you'll get an error message, ngl. 😭

def delete_policy(conn):
    print("Delete Policy:")

    conn.clustering.delete_policy('dp01')

    print("Policy deleted.")

🌈 Managing Receivers

Receivers are the event sinks tied to senlin clusters — think of them as the inbox for events. So when some monitoring software spots certain events (or alarms), that software can notify the senlin clusters about them. And when senlin gets those notifications? It can automatically trigger predefined operations with preset parameter values. Main character energy, honestly. 👑

🍓 List Receivers

To peek at the list of receivers:

def list_receivers(conn):
    print("List Receivers:")

    for receiver in conn.clustering.receivers():
        print(receiver.to_dict())

    for receiver in conn.clustering.receivers(sort='name:asc'):
        print(receiver.to_dict())

When you're listing receivers, the sort parameter handles sorting for you, and you can do pagination with the limit and marker parameters. 💖

Full example: manage receiver <https://opendev.org/openstack/openstacksdk/src/branch/master/examples/clustering/receiver.py>

🧚 Create Receiver

When you create a receiver, you pass a dictionary of keys and values that match the receiver type you referenced:

def create_receiver(conn):
    print("Create Receiver:")

    # Build the receiver attributes and create the recever.
    spec = {
        "action": "CLUSTER_SCALE_OUT",
        "cluster_id": CLUSTER_ID,
        "name": FAKE_NAME,
        "params": {"count": "1"},
        "type": "webhook",
    }

    receiver = conn.clustering.create_receiver(**spec)
    print(receiver.to_dict())

Optionally, you can throw in a metadata keyword argument — a bunch of key-value pairs to associate with the receiver. 🎀

Full example: manage receiver <https://opendev.org/openstack/openstacksdk/src/branch/master/examples/clustering/receiver.py>

💜 Get Receiver

Getting a receiver by its name or ID:

def get_receiver(conn):
    print("Get Receiver:")

    receiver = conn.clustering.get_receiver(FAKE_NAME)
    print(receiver.to_dict())

Full example: manage receiver <https://opendev.org/openstack/openstacksdk/src/branch/master/examples/clustering/receiver.py>

🔥 Find Receiver

Finding a receiver by its name or ID:

def find_receiver(conn):
    print("Find Receiver:")

    receiver = conn.clustering.find_receiver(FAKE_NAME)
    print(receiver.to_dict())

Full example: manage receiver <https://opendev.org/openstack/openstacksdk/src/branch/master/examples/clustering/receiver.py>

🌸 Update Receiver

Once a receiver exists, most of its properties are immutable. But bestie, you can update a receiver's name and/or params:

def update_receiver(conn):
    print("Update Receiver:")

    spec = {"name": "test_receiver2", "params": {"count": "2"}}
    receiver = conn.clustering.update_receiver(FAKE_NAME, **spec)
    print(receiver.to_dict())

Full example: manage receiver <https://opendev.org/openstack/openstacksdk/src/branch/master/examples/clustering/receiver.py>

🦋 Delete Receiver

A receiver can be deleted after creation — provided it's not referenced by any active clusters. Try to delete one that's still in use and you'll get an error message. 🙈

def delete_receiver(conn):
    print("Delete Receiver:")

    conn.clustering.delete_receiver(FAKE_NAME)
    print("Receiver deleted.")

⚡ Working with Actions

An action is basically an abstraction of some logic that a worker thread can execute. Most of the operations Senlin supports run asynchronously — meaning they get queued up into the database and then picked up by a certain worker thread for execution. Queue it and forget it, iykyk. 💅

⭐ List Actions

To look at the list of actions:

def list_actions(conn):
    print("List Actions:")

    for actions in conn.clustering.actions():
        print(actions.to_dict())

    for actions in conn.clustering.actions(sort='name:asc'):
        print(actions.to_dict())

When listing actions, sort handles your sorting, and pagination is done with the limit and marker parameters. ✨

Full example: manage action <https://opendev.org/openstack/openstacksdk/src/branch/master/examples/clustering/action.py>

🎀 Get Action

Getting an action by its name or ID:

def get_action(conn):
    print("Get Action:")

    action = conn.clustering.get_action(ACTION_ID)
    print(action.to_dict())

🦋 Working with Events

An event is a record generated during engine execution. It captures what happened inside the senlin-engine. The senlin-engine service generates those event records while it's performing actions or checking policies. Receipts, basically. 🧾

💖 List Events

To examine the list of events:

def list_events(conn):
    print("List Events:")

    for events in conn.clustering.events():
        print(events.to_dict())

    for events in conn.clustering.events(sort='name:asc'):
        print(events.to_dict())

When listing events, the sort parameter sorts them, and you can paginate using the limit and marker parameters. 🌸

Full example: manage event <https://opendev.org/openstack/openstacksdk/src/branch/master/examples/clustering/event.py>

🌈 Get Event

Getting an event by its name or ID:

def get_event(conn):
    print("Get Event:")

    event = conn.clustering.get_event(EVENT_ID)
    print(event.to_dict())

👑 Using OpenStack Compute

Before you start working with the Compute service, you gotta create a connection to your OpenStack cloud — just follow the Connect <> user guide. That'll hand you the conn variable used in all the examples below. 🫶

📋 Table of Contents

List Servers
List Images
List Flavors
List Networks
Create Key Pair
Create Server

The primary resource of the Compute service is the server. Periodt.

💻 List Servers

A server is a virtual machine that gives you access to a compute instance being run by your cloud provider.

def list_servers(conn):
    print("List Servers:")

    for server in conn.compute.servers():
        print(server)

Full example: compute resource list <https://opendev.org/openstack/openstacksdk/src/branch/master/examples/compute/list.py>

🖼️ List Images

An image is the operating system you want to use for your server. 💿

def list_images(conn):
    print("List Images:")

    for image in conn.compute.images():
        print(image)

Full example: compute resource list <https://opendev.org/openstack/openstacksdk/src/branch/master/examples/compute/list.py>

🍓 List Flavors

A flavor is the resource configuration for a server — every flavor is a unique combo of disk, memory, vCPUs, and network bandwidth. 🍰

def list_flavors(conn):
    print("List Flavors:")

    for flavor in conn.compute.flavors():
        print(flavor)

Full example: compute resource list <https://opendev.org/openstack/openstacksdk/src/branch/master/examples/compute/list.py>

🌐 List Networks

A network provides connectivity to servers.

def list_networks(conn):
    print("List Networks:")

    for network in conn.network.networks():
        print(network)

Full example: network resource list <https://opendev.org/openstack/openstacksdk/src/branch/master/examples/network/list.py>

🎀 Create Key Pair

A key pair is the public key and private key of public–key cryptography <https://en.wikipedia.org/wiki/Public-key_cryptography>. Bestie, they're literally how you encrypt and decrypt your login info when you connect to your server 🔐✨

def create_keypair(conn):
    keypair = conn.compute.find_keypair(KEYPAIR_NAME)

    if not keypair:
        print("Create Key Pair:")

        keypair = conn.compute.create_keypair(name=KEYPAIR_NAME)

        print(keypair)

        try:
            os.mkdir(SSH_DIR)
        except OSError as e:
            if e.errno != errno.EEXIST:
                raise e

        with open(PRIVATE_KEYPAIR_FILE, 'w') as f:
            f.write(str(keypair.private_key))

        os.chmod(PRIVATE_KEYPAIR_FILE, 0o400)

    return keypair

Full example: compute resource create <https://opendev.org/openstack/openstacksdk/src/branch/master/examples/compute/create.py>

🦋 Create Server

Okay so at minimum a server needs a name, an image, a flavor, and a network when you create it. You can discover the names and IDs of these attributes by listing them as above and then using the find methods to grab the right resources 💅

Ideally you'll also create a server using a keypair so you can login to that server with the private key. iykyk 🔑

Servers take time to boot, so we call wait_for_server to wait for it to become active — patience, queen 👑

def create_server(conn):
    print("Create Server:")

    image = conn.image.find_image(IMAGE_NAME)
    flavor = conn.compute.find_flavor(FLAVOR_NAME)
    network = conn.network.find_network(NETWORK_NAME)
    keypair = create_keypair(conn)

    server = conn.compute.create_server(
        name=SERVER_NAME,
        image_id=image.id,
        flavor_id=flavor.id,
        networks=[{"uuid": network.id}],
        key_name=keypair.name,
    )

    server = conn.compute.wait_for_server(server)

    print(f"ssh -i {PRIVATE_KEYPAIR_FILE} root@{server.access_ipv4}")

Full example: compute resource create <https://opendev.org/openstack/openstacksdk/src/branch/master/examples/compute/create.py>

🌸 Using OpenStack Database

Before working with the Database service, you'll need to create a connection to your OpenStack cloud by following the Connect <> user guide. That's what gives you the conn variable used in the examples below 🫶

✨ Table of Contents

Working with Instances
Working with Databases and Users
Working with Flavors

The Database service provisions database instances and manages the databases, users and flavors associated with them. The examples below show a representative subset of what's possible — for the complete set of operations, see the Database proxy reference <> 👑

💜 Working with Instances

To list the existing database instances, use the instances() method, which returns a generator of Instance <#openstack.database.v1.instance.Instance> objects:

>>> for instance in conn.database.instances():
...     print(instance.name, instance.status)

To create an instance, use the create_instance() method. To retrieve or delete one, use get_instance() and delete_instance():

>>> instance = conn.database.create_instance(
...     name='my-instance', flavor_reference=flavor.id, volume={'size': 5})
>>> conn.database.delete_instance(instance)

🍓 Working with Databases and Users

Databases and users are created against an existing instance. Use create_database() and create_user(), and list them with databases() and users():

>>> conn.database.create_database(instance, name='my-database')
>>> conn.database.create_user(
...     instance, name='alice', password='s3cret')

🌈 Working with Flavors

Flavors describe the compute and memory resources of an instance. List the available flavors with flavors():

>>> for flavor in conn.database.flavors():
...     print(flavor.name)

🧚 Using OpenStack DNS

Before working with the DNS service, you'll need to create a connection to your OpenStack cloud by following the Connect <> user guide. That'll hand you the conn variable used in the examples below ✨

🎀 Table of Contents

List Zones
List Recordsets
Create Zone
Create Recordset
Delete Zone
Delete Recordset
Find Zone
Find Recordset

The primary resource of the DNS service is the server. (Yes, that's what it says. Not me, the docs 💀)

🌸 List Zones

Zone is a logical grouping of DNS records for a domain, allowing for the centralized management of DNS resources, including domain names, nameservers, and DNS queries 🗂️

def list_zones(conn):
    print("List Zones:")

    for zone in conn.dns.zones():
        print(zone)

Full example: dns resource list <https://opendev.org/openstack/openstacksdk/src/branch/master/examples/dns/list.py>

🦋 List Recordsets

Recordsets allow for the centralized management of various DNS records within a Zone, helping to define how a domain responds to different types of DNS queries 📋

def list_recordsets(conn, name_or_id):
    print("List Recordsets for Zone")

    zone = conn.dns.find_zone(name_or_id)

    if zone:
        zone_id = zone.id
        recordsets = conn.dns.recordsets(zone_id)

        for recordset in recordsets:
            print(recordset)
    else:
        print("Zone not found.")

Full example: dns resource list <https://opendev.org/openstack/openstacksdk/src/branch/master/examples/dns/list.py>

💜 Create Zone

Create a zone. It allows users to define and manage the DNS namespace for a particular domain 👑

def create_zone(
    conn,
    name,
    email,
    ttl=3600,
    description="Default description",
    zone_type="PRIMARY",
):
    print("Create Zone: ")

    zone = {
        "name": name,
        "email": email,
        "ttl": ttl,
        "description": description,
        "type": zone_type,
    }

    print(conn.dns.create_zone(**zone))

Full example: dns resource list <https://opendev.org/openstack/openstacksdk/src/branch/master/examples/dns/list.py>

🍓 Create Recordset

Create a recordset. It accepts several parameters that define the DNS record's properties and sends an API request to OpenStack to create the recordset within a specified DNS zone 🔥

def create_recordset(
    conn,
    name_or_id,
    recordset_name,
    recordset_type="A",
    records=["192.168.1.1"],
    ttl=3600,
    description="Default description",
):
    print("Create Recordset: ")

    zone = conn.dns.find_zone(name_or_id)

    if not zone:
        print("Zone not found.")
        return None

    zone_id = zone.id

    recordset_data = {
        "name": recordset_name,
        "type": recordset_type,
        "records": records,
        "ttl": ttl,
        "description": description,
    }

    print(conn.dns.create_recordset(zone_id, **recordset_data))

Full example: dns resource list <https://opendev.org/openstack/openstacksdk/src/branch/master/examples/dns/list.py>

🌈 Delete Zone

Delete a zone. It allows users to completely delete the DNS management for a specified domain 💀

def delete_zone(conn, name_or_id):
    print(f"Delete Zone: {name_or_id}")

    zone = conn.dns.find_zone(name_or_id)

    if zone:
        conn.dns.delete_zone(zone.id)
    else:
        return None

Full example: dns resource list <https://opendev.org/openstack/openstacksdk/src/branch/master/examples/dns/list.py>

🧚 Delete Recordset

Delete a recordset. Just... poof, gone ✨

def delete_recordset(conn, name_or_id, recordset_name):
    print(f"Deleting Recordset: {recordset_name} in Zone: {name_or_id}")

    zone = conn.dns.find_zone(name_or_id)

    if zone:
        try:
            recordset = conn.dns.find_recordset(zone.id, recordset_name)
            if recordset:
                conn.dns.delete_recordset(recordset, zone.id)
            else:
                print("Recordset not found")
        except Exception as e:
            print(f"{e}")
    else:
        return None

Full example: dns resource list <https://opendev.org/openstack/openstacksdk/src/branch/master/examples/dns/list.py>

🎀 Find Zone

The find_zone function searches for and returns a DNS zone by its name using a given connection object 🔍

def find_zone(conn, name_or_id):
    print(f"Find Zone: {name_or_id}")

    zone = conn.dns.find_zone(name_or_id)

    if zone:
        print(zone)
        return zone
    else:
        print("Zone not found.")
        return None

Full example: dns resource list <https://opendev.org/openstack/openstacksdk/src/branch/master/examples/dns/list.py>

🦋 Find Recordset

The find_recordset function searches for a DNS recordset with a specific name and type within a given zone. If multiple recordsets with the same name exist, the record type can be specified to find the exact match 🎯

def find_recordset(conn, name_or_id, recordset_name, recordset_type=None):
    print(f"Find Recordset: {recordset_name} in Zone: {name_or_id}")

    zone = conn.dns.find_zone(name_or_id)

    if not zone:
        print("Zone not found.")
        return None

    zone_id = zone.id

    try:
        if recordset_type:
            recordset = conn.dns.find_recordset(
                zone_id, recordset_name, type=recordset_type
            )
        else:
            recordset = conn.dns.find_recordset(zone_id, recordset_name)

        if recordset:
            print(recordset)
            return recordset
        else:
            print("Recordset not found in Zone.")
            return None

    except Exception as e:
        print(f"{e}")
        return None

Full example: dns resource list <https://opendev.org/openstack/openstacksdk/src/branch/master/examples/dns/list.py>

💜 Using OpenStack Identity

Before working with the Identity service, you'll need to create a connection to your OpenStack cloud by following the Connect <> user guide. That's the whole vibe check that gives you the conn variable used in the examples below 🫶

okay so the OpenStack Identity service is literally the default identity management system for OpenStack, no cap. Its authentication process confirms who a user is and checks an incoming request by validating the credentials that user hands over. At first, those credentials are a user name and password, or a user name and API key. Once the Identity service validates them, it issues an authentication token that the user sends in later requests. That token is an alpha-numeric text string that unlocks access to OpenStack APIs and resources. It can be revoked at any time, and it’s only valid for a finite duration. 💅

🎀 List Users 🎀

A user is a digital representation of a person, system, or service that uses OpenStack cloud services. The Identity service validates that incoming requests are made by the user who claims to be making the call. Users have a login and can access resources by using assigned tokens. Users can be directly assigned to a particular project and behave as if they are contained in that project. Periodt.

def list_users(conn):
    print("List Users:")

    for user in conn.identity.users():
        print(user)

Full example: identity resource list — https://opendev.org/openstack/openstacksdk/src/branch/master/examples/identity/list.py

💖 List Credentials 💖

Credentials are data that confirms the identity of the user. For example: user name and password, user name and API key, or an authentication token that the Identity service provides. Iconic little identity receipts, honestly.

def list_credentials(conn):
    print("List Credentials:")

    for credential in conn.identity.credentials():
        print(credential)

Full example: identity resource list — https://opendev.org/openstack/openstacksdk/src/branch/master/examples/identity/list.py

🦋 List Projects 🦋

A project is a container that groups or isolates resources or identity objects. It’s giving organizational bubble, and we love that for it.

def list_projects(conn):
    print("List Projects:")

    for project in conn.identity.projects():
        print(project)

Full example: identity resource list — https://opendev.org/openstack/openstacksdk/src/branch/master/examples/identity/list.py

🌸 List Domains 🌸

A domain is an Identity service API v3 entity and represents a collection of projects and users that defines administrative boundaries for the management of Identity entities. Users can be granted the administrator role for a domain. A domain administrator can create projects, users, and groups in a domain and assign roles to users and groups in a domain.

def list_domains(conn):
    print("List Domains:")

    for domain in conn.identity.domains():
        print(domain)

Full example: identity resource list — https://opendev.org/openstack/openstacksdk/src/branch/master/examples/identity/list.py

🫶 List Groups 🫶

A group is an Identity service API v3 entity and represents a collection of users that are owned by a domain. A group role granted to a domain or project applies to all users in the group. Adding users to, or removing users from, a group respectively grants, or revokes, their role and authentication to the associated domain or project.

def list_groups(conn):
    print("List Groups:")

    for group in conn.identity.groups():
        print(group)

Full example: identity resource list — https://opendev.org/openstack/openstacksdk/src/branch/master/examples/identity/list.py

✨ List Services ✨

A service is an OpenStack service, such as Compute, Object Storage, or Image service, that provides one or more endpoints through which users can access resources and perform operations.

def list_services(conn):
    print("List Services:")

    for service in conn.identity.services():
        print(service)

Full example: identity resource list — https://opendev.org/openstack/openstacksdk/src/branch/master/examples/identity/list.py

🎀 List Endpoints 🎀

An endpoint is a network-accessible address, usually a URL, through which you can access a service.

def list_endpoints(conn):
    print("List Endpoints:")

    for endpoint in conn.identity.endpoints():
        print(endpoint)

Full example: identity resource list — https://opendev.org/openstack/openstacksdk/src/branch/master/examples/identity/list.py

🌈 List Regions 🌈

A region is an Identity service API v3 entity and represents a general division in an OpenStack deployment. You can associate zero or more sub-regions with a region to make a tree-like structured hierarchy.

def list_regions(conn):
    print("List Regions:")

    for region in conn.identity.regions():
        print(region)

Full example: identity resource list — https://opendev.org/openstack/openstacksdk/src/branch/master/examples/identity/list.py

🦋 Using OpenStack Image 🦋

Before working with the Image service, you’ll need to create a connection to your OpenStack cloud by following the Connect <> user guide. This will provide you with the conn variable used in the examples below.

The primary resource of the Image service is the image. Main character energy, obviously.

🍓 List Images 🍓

An image is a collection of files for a specific operating system that you use to create or rebuild a server. OpenStack provides pre-built images — http://docs.openstack.org/image-guide/obtain-images.html. You can also create custom images, or snapshots, from servers that you have launched. Images come in different formats and are sometimes called virtual machine images. Obsessed.

def list_images(conn):
    print("List Images:")

    for image in conn.image.images():
        print(image)

Full example: image resource list — https://opendev.org/openstack/openstacksdk/src/branch/master/examples/image/list.py

💜 Create Image 💜

Create an image by uploading its data and setting its attributes. That’s the whole vibe.

def upload_image(conn):
    print("Upload Image:")

    # Load fake image data for the example.
    data = 'This is fake image data.'

    # Build the image attributes and upload the image.
    image_attrs = {
        'name': EXAMPLE_IMAGE_NAME,
        'data': data,
        'disk_format': 'raw',
        'container_format': 'bare',
        'visibility': 'public',
    }
    conn.image.upload_image(**image_attrs)

Full example: image resource create — https://opendev.org/openstack/openstacksdk/src/branch/master/examples/image/create.py

🧚 Create Image via interoperable image import process 🧚

Create an image, then use interoperable image import process to download data from a web URL.

For more information about the image import process, please check interoperable image import — https://docs.openstack.org/glance/latest/admin/interoperable-image-import.html

def import_image(conn):
    print("Import Image:")

    # Url where glance can download the image
    uri = (
        'https://download.cirros-cloud.net/0.4.0/cirros-0.4.0-x86_64-disk.img'
    )

    # Build the image attributes and import the image.
    image_attrs = {
        'name': EXAMPLE_IMAGE_NAME,
        'disk_format': 'qcow2',
        'container_format': 'bare',
        'visibility': 'public',
    }
    image = conn.image.create_image(**image_attrs)
    conn.image.import_image(image, method="web-download", uri=uri)

Full example: image resource import — https://opendev.org/openstack/openstacksdk/src/branch/master/examples/image/import.py

💀 Downloading an Image with `stream=True` 💀

As images are often very large pieces of data, storing their entire contents in the memory of your application can be less than desirable. A more efficient method may be to iterate over a stream of the response data.

By choosing to stream the response content, you determine the chunk_size that is appropriate for your needs, meaning only that many bytes of data are read for each iteration of the loop until all data has been consumed. See requests.Response.iter_content() for more information.

When you choose to stream an image download, openstacksdk is no longer able to compute the checksum of the response data for you. This example shows how you might do that yourself, in a very similar manner to how the library calculates checksums for non-streamed responses. Ngl, you’re on checksum duty now.

def download_image_stream(conn):
    print("Download Image via streaming:")

    # Find the image you would like to download.
    image = conn.image.find_image("myimage")

    # As the actual download now takes place outside of the library
    # and in your own code, you are now responsible for checking
    # the integrity of the data. Create an MD5 has to be computed
    # after all of the data has been consumed.
    md5 = hashlib.md5(usedforsecurity=False)

    with open("myimage.qcow2", "wb") as local_image:
        response = conn.image.download_image(image, stream=True)

        # Read only 1 MiB of memory at a time until
        # all of the image data has been consumed.
        for chunk in response.iter_content(chunk_size=1024 * 1024):
            # With each chunk, add it to the hash to be computed.
            md5.update(chunk)

            local_image.write(chunk)

        # Now that you've consumed all of the data the response gave you,
        # ensure that the checksums of what the server offered and
        # what you downloaded are the same.
        if response.headers["Content-MD5"] != md5.hexdigest():
            raise Exception("Checksum mismatch in downloaded content")

🙈 Downloading an Image with `stream=False` 🙈

If you wish to download an image’s contents all at once and to memory, simply set stream=False, which is the default. Easy.

def download_image(conn):
    print("Download Image:")

    # Find the image you would like to download.
    image = conn.image.find_image("myimage")

    with open("myimage.qcow2", "w") as local_image:
        response = conn.image.download_image(image)

        # Response will contain the entire contents of the Image.
        local_image.write(response)

Full example: image resource download — https://opendev.org/openstack/openstacksdk/src/branch/master/examples/image/download.py

👑 Delete Image 👑

Delete an image. Bye bestie.

def delete_image(conn):
    print("Delete Image:")

    example_image = conn.image.find_image(EXAMPLE_IMAGE_NAME)

    conn.image.delete_image(example_image, ignore_missing=False)

Full example: image resource delete — https://opendev.org/openstack/openstacksdk/src/branch/master/examples/image/delete.py

💖 Using OpenStack Key Manager 💖

Okay bestie, before you can vibe with the Key Manager service, you gotta make a connection to your OpenStack cloud by following the Connect <> user guide. That's what gives you the conn variable used in all the examples below, periodt ✨

🎀 Table of Contents 🎀

Create a Secret
List Secrets
Get Secret Payload
Find Secret
Delete Secret
Create a Secret Consumer
List Secret Consumers
Delete Secret Consumer

⚠️ Note, bestie: some interactions with the Key Manager service differ from other services in that resources do not have a proper id parameter, and like… you need that for some calls 😭 Instead, resources have a separately named id attribute, e.g., the Secret resource has secret_id. The examples below show you exactly when to pass in those id values. Don't skip this, iykyk 💅

🔐 Create a Secret

The Key Manager service lets you create new secrets by passing the attributes of the Secret <#openstack.key_manager.v1.secret.Secret> to the create_secret() method. Slay 🫶

def create_secret(conn):
    print("Create a secret:")

    conn.key_manager.create_secret(
        name="My public key",
        secret_type="public",
        expiration="2020-02-28T23:59:59",
        payload="ssh rsa...",
        payload_content_type="text/plain",
    )

📋 List Secrets

Once you've stored some secrets, they're available for you to list via the secrets() method. This method returns a generator, which yields each Secret <#openstack.key_manager.v1.secret.Secret>. Iconic behavior honestly ✨

def list_secrets(conn):
    print("List Secrets:")

    for secret in conn.key_manager.secrets():
        print(secret)

The secrets() method can also make more advanced queries to limit the secrets that are returned. Fancy 💅

def list_secrets_query(conn):
    print("List Secrets:")

    for secret in conn.key_manager.secrets(
        secret_type="symmetric", expiration="gte:2020-01-01T00:00:00"
    ):
        print(secret)

🔑 Get Secret Payload

Once you've received a Secret <#openstack.key_manager.v1.secret.Secret>, you can obtain the payload for it by passing the secret's id value to the secrets() method. Use the secret_id attribute when making this request — yes, the separately-named one, that's the whole vibe check from earlier 💀

def get_secret_payload(conn):
    print("Get a secret's payload:")

    # Assuming you have an object `s` which you perhaps received from
    # a conn.key_manager.secrets() call...
    secret = conn.key_manager.get_secret(s.secret_id)
    print(secret.payload)

🔍 Find Secret

To find a secret by name or ID, use the find_secret() method. This method can search for a Secret <#openstack.key_manager.v1.secret.Secret> by either its name or ID, making it flexible when you don't have the exact secret ID. Literally so convenient 🌸

def find_secret(conn, name_or_id):
    print(f"Find Secret: {name_or_id}")

    secret = conn.key_manager.find_secret(name_or_id)

    if secret:
        print(secret)
        return secret
    else:
        print("Secret not found")
        return None

🗑️ Delete Secret

To delete a secret, use the delete_secret() method. The secret can be identified by its ID or by using find_secret() to locate it by name first. Main character energy from find_secret() ngl 👑

def delete_secret(conn, name_or_id):
    print(f"Delete Secret: {name_or_id}")

    secret = conn.key_manager.find_secret(name_or_id)

    if secret:
        conn.key_manager.delete_secret(secret)
    else:
        print("Secret not found")

🧚 Create a Secret Consumer

The Key Manager service lets you create a secret consumer by passing the attributes of the SecretConsumer <#openstack.key_manager.v1.secret_consumer.SecretConsumer> to the create_secret_consumer() method. Obsessed 🎀

def create_secret_consumer(conn):
    print("Create a secret consumer:")

    secret = conn.key_manager.find_secret("My public key")

    conn.key_manager.create_secret_consumer(
        secret=secret,
        service="service",
        resource_type="resource_type",
        resource_id="resource-id",
    )

📜 List Secret Consumers

The Key Manager service lets you list secret consumers by passing the attributes of the SecretConsumer <#openstack.key_manager.v1.secret_consumer.SecretConsumer> to the secret_consumers() method.

def list_secret_consumers(conn, secret):
    print("List Secret Consumers:")

    for consumer in conn.key_manager.secret_consumers(secret=secret):
        print(consumer)

❌ Delete Secret Consumer

The Key Manager service lets you delete a secret consumer by passing the attributes of the SecretConsumer <#openstack.key_manager.v1.secret_consumer.SecretConsumer> to the delete_secret_consumer() method. Bye bestie 👋

def delete_secret_consumer(conn, secret):
    print("Delete a secret consumer:")

    conn.key_manager.delete_secret_consumer(
        secret=secret,
        service="service",
        resource_type="resource_type",
        resource_id="resource-id",
    )

💌 Using OpenStack Message 💌

Before working with the Message service, you'll need to create a connection to your OpenStack cloud by following the Connect <> user guide. That gives you the conn variable used in the examples below. Yes, same drill every time, it's giving consistent 💅

🎀 Table of Contents 🎀

Working with Queues
Working with Messages
Subscriptions and Claims

The Message service provides message queues, along with the messages, subscriptions and claims associated with them. The examples below show a representative subset of what's possible; for the complete set of operations, see the Message proxy reference <>. Lowkey there's so much more, go look 🔥

📬 Working with Queues

To list the existing queues, use the queues() method, which returns a generator of Queue objects. Create and delete queues with create_queue() and delete_queue():

>>> queue = conn.message.create_queue(name='my-queue')
>>> for queue in conn.message.queues():
...     print(queue.name)

✉️ Working with Messages

Producers post messages to a queue with post_message(), and consumers read them back with messages():

>>> conn.message.post_message(
...     queue.name, messages=[{'body': 'hello', 'ttl': 300}])
>>> for message in conn.message.messages(queue.name):
...     print(message.body)

🧾 Subscriptions and Claims

Subscriptions notify an endpoint when messages arrive; manage them with create_subscription() and subscriptions(). Claims let a consumer reserve a batch of messages for processing; manage them with create_claim() and the related claim methods. Cute little system, honestly 🦋

🌐 Using OpenStack Network 🌐

Before working with the Network service, you'll need to create a connection to your OpenStack cloud by following the Connect <> user guide. Same deal, that's where conn comes from, you know the vibe by now 💖

🎀 Table of Contents 🎀

List Networks
List Subnets
List Ports
List Security Groups
List Routers
List Network Agents
Create Network
Open a Port
Accept Pings
Delete Network

The primary resource of the Network service is the network. Periodt.

🕸️ List Networks

A network is an isolated Layer 2 <https://en.wikipedia.org/wiki/Data_link_layer> networking segment. There are two types of networks, project and provider networks. Project networks are fully isolated and are not shared with other projects. Provider networks map to existing physical networks in the data center and provide external network access for servers. Only an OpenStack administrator can create provider networks. Networks can be connected via routers. So much lore honestly 😭

def list_networks(conn):
    print("List Networks:")

    for network in conn.network.networks():
        print(network)

Full example: network resource list <https://opendev.org/openstack/openstacksdk/src/branch/master/examples/network/list.py>

🧩 List Subnets

A subnet is a block of IP addresses and associated configuration state. Subnets are used to allocate IP addresses when new ports are created on a network. That's it, that's the whole subnet 🫶

def list_subnets(conn):
    print("List Subnets:")

    for subnet in conn.network.subnets():
        print(subnet)

Full example: network resource list <https://opendev.org/openstack/openstacksdk/src/branch/master/examples/network/list.py>

🔌 List Ports

A port is a connection point for attaching a single device, such as the NIC <https://en.wikipedia.org/wiki/Network_interface_controller> of a server, to a network. The port also describes the associated network configuration, such as the MAC <https://en.wikipedia.org/wiki/Media_access_control> and IP addresses to be used on that port. Very demure, very network-y ✨

def list_ports(conn):
    print("List Ports:")

    for port in conn.network.ports():
        print(port)

Full example: network resource list <https://opendev.org/openstack/openstacksdk/src/branch/master/examples/network/list.py>

🛡️ List Security Groups

A security group acts as a virtual firewall for servers. It's a container for security group rules which specify the type of network traffic and direction that is allowed to pass through a port. Protecting the servers, we love to see it 💅

def list_security_groups(conn):
    print("List Security Groups:")

    for port in conn.network.security_groups():
        print(port)

Full example: network resource list <https://opendev.org/openstack/openstacksdk/src/branch/master/examples/network/list.py>

🛣️ List Routers

A router is a logical component that forwards data packets between networks. It also provides Layer 3 <https://en.wikipedia.org/wiki/Network_layer> and NAT <https://en.wikipedia.org/wiki/Network_address_translation> forwarding to provide external network access for servers on project networks. Iconic forwarding behavior 👑

def list_routers(conn):
    print("List Routers:")

    for router in conn.network.routers():
        print(router)

Full example: network resource list <https://opendev.org/openstack/openstacksdk/src/branch/master/examples/network/list.py>

🤖 List Network Agents

A network agent is a plugin that handles various tasks used to implement virtual networks. These agents include neutron-dhcp-agent, neutron-l3-agent, neutron-metering-agent, and neutron-lbaas-agent, among others. Little worker bees fr fr 🐝

def list_network_agents(conn):
    print("List Network Agents:")

    for agent in conn.network.agents():
        print(agent)

Full example: network resource list <https://opendev.org/openstack/openstacksdk/src/branch/master/examples/network/list.py>

Create Network 🌸

Okay so you're making a project network and subnet. This network can be used when creating a server and lets the server talk to other servers on the same project network. Here's the function:

def create_network(conn):
    print("Create Network:")

    example_network = conn.network.create_network(
        name='openstacksdk-example-project-network'
    )

    print(example_network)

    example_subnet = conn.network.create_subnet(
        name='openstacksdk-example-project-subnet',
        network_id=example_network.id,
        ip_version='4',
        cidr='10.0.2.0/24',
        gateway_ip='10.0.2.1',
    )

    print(example_subnet)

Full example: network resource create — https://opendev.org/openstack/openstacksdk/src/branch/master/examples/network/create.py

Open a Port 🔓

When you're creating a security group for a network, you need to open certain ports so communication can happen through them. For example, you might need to enable HTTPS access on port 443.

def open_port(conn):
    print("Open a port:")

    example_sec_group = conn.network.create_security_group(
        name='openstacksdk-example-security-group'
    )

    print(example_sec_group)

    example_rule = conn.network.create_security_group_rule(
        security_group_id=example_sec_group.id,
        direction='ingress',
        remote_ip_prefix='0.0.0.0/0',
        protocol='tcp',
        port_range_max='443',
        port_range_min='443',
        ethertype='IPv4',
    )

    print(example_rule)

Full example: network security group create — https://opendev.org/openstack/openstacksdk/src/branch/master/examples/network/security_group_rules.py

Accept Pings 🏓

To ping a machine on your network inside a security group, you need to create a rule that allows inbound ICMP packets. Iconic networking behavior, honestly.

def allow_ping(conn):
    print("Allow pings:")

    example_sec_group = conn.network.create_security_group(
        name='openstacksdk-example-security-group2'
    )

    print(example_sec_group)

    example_rule = conn.network.create_security_group_rule(
        security_group_id=example_sec_group.id,
        direction='ingress',
        remote_ip_prefix='0.0.0.0/0',
        protocol='icmp',
        port_range_max=None,
        port_range_min=None,
        ethertype='IPv4',
    )

    print(example_rule)

Full example: network security group create — https://opendev.org/openstack/openstacksdk/src/branch/master/examples/network/security_group_rules.py

Delete Network 🗑️

This deletes a project network and its subnets. Bye-bye, little network.

def delete_network(conn):
    print("Delete Network:")

    example_network = conn.network.find_network(
        'openstacksdk-example-project-network'
    )

    for example_subnet in example_network.subnet_ids:
        conn.network.delete_subnet(example_subnet, ignore_missing=False)
    conn.network.delete_network(example_network, ignore_missing=False)

Full example: network resource delete — https://opendev.org/openstack/openstacksdk/src/branch/master/examples/network/delete.py

Using OpenStack Object Store 🦋

Before working with the Object Store service, you'll need to create a connection to your OpenStack cloud by following the Connect <> user guide. That gives you the conn variable used in the examples below.

Table of Contents 📚

Working with Containers
- Listing Containers
- Creating Containers
- Working with Container Metadata
Working with Objects
- Listing Objects
- Getting Object Data
- Uploading Objects
- Working with Object Metadata

The primary resources of the Object Store service are containers and objects. 💖

Working with Containers 🧺

Listing Containers 🔍

To list existing containers, use the containers() method.

>>> for cont in conn.object_store.containers():
...     print cont
...
openstack.object_store.v1.container.Container: {u'count': 5,
u'bytes': 500, u'name': u'my container'}
openstack.object_store.v1.container.Container: {u'count': 0,
u'bytes': 0, u'name': u'empty container'}
openstack.object_store.v1.container.Container: {u'count': 100,
u'bytes': 1000000, u'name': u'another container'}

The containers method returns a generator that yields Container <#openstack.object_store.v1.container.Container> objects. It handles pagination for you, and you can adjust that with the limit argument. By default, it yields as many containers as the service will return, and it keeps requesting until it gets no more.

>>> for cont in conn.object_store.containers(limit=500):
...     print(cont)
...
<500 Containers>
... another request transparently made to the Object Store service
<500 more Containers>
...

Creating Containers 🎁

To create a container, use the create_container() method.

>>> cont = conn.object_store.create_container(name="new container")
>>> cont
openstack.object_store.v1.container.Container: {'name': u'new container'}

Working with Container Metadata 🏷️

To get the metadata for a container, use the get_container_metadata() method. This method either takes the name of a container or a Container <#openstack.object_store.v1.container.Container> object, and it returns a Container object with all of its metadata attributes set.

>>> cont = conn.object_store.get_container_metadata("new container")
openstack.object_store.v1.container.Container: {'content-length': '0',
'x-container-object-count': '0', 'name': u'new container',
'accept-ranges': 'bytes',
'x-trans-id': 'tx22c5de63466e4c05bb104-0054740c39',
'date': 'Tue, 25 Nov 2014 04:57:29 GMT',
'x-timestamp': '1416889793.23520', 'x-container-read': '.r:mysite.com',
'x-container-bytes-used': '0', 'content-type': 'text/plain; charset=utf-8'}

To set the metadata for a container, use the set_container_metadata() method. This method takes a Container <#openstack.object_store.v1.container.Container> object. For example, to grant another user write access to this container, you can call set_container_metadata passing it the Container to update and keyword argument key/value pairs representing the metadata name and value to set.

>>> acl = "big_project:another_user"
>>> conn.object_store.set_container_metadata(cont, write_ACL=acl)
openstack.object_store.v1.container.Container: {'content-length': '0',
'x-container-object-count': '0',
'name': u'my new container', 'accept-ranges': 'bytes',
'x-trans-id': 'txc3ee751f971d41de9e9f4-0054740ec1',
'date': 'Tue, 25 Nov 2014 05:08:17 GMT',
'x-timestamp': '1416889793.23520', 'x-container-read': '.r:mysite.com',
'x-container-bytes-used': '0', 'content-type': 'text/plain; charset=utf-8',
'x-container-write': 'big_project:another_user'}

Working with Objects 📦

Objects are held in containers. From an API standpoint, you work with them using similarly named methods, typically with an additional argument to specify their container.

Listing Objects 🔎

To list the objects that exist in a container, use the objects() method.

If you have a Container <#openstack.object_store.v1.container.Container> object, you can pass it to objects.

>>> print cont.name
pictures
>>> for obj in conn.object_store.objects(cont):
...     print obj
...
openstack.object_store.v1.container.Object:
{u'hash': u'0522d4ccdf9956badcb15c4087a0c4cb',
u'name': u'pictures/selfie.jpg', u'bytes': 15744,
'last-modified': u'2014-10-31T06:33:36.618640',
u'last_modified': u'2014-10-31T06:33:36.618640',
u'content_type': u'image/jpeg', 'container': u'pictures',
'content-type': u'image/jpeg'}
...

Similar to the containers() method, objects returns a generator which yields Object <#openstack.object_store.v1.obj.Object> objects stored in the container. It also handles pagination for you, which you can adjust with the limit parameter, otherwise making each request for the maximum that your Object Store will return.

If you have the name of a container instead of an object, you can also pass that to the objects method.

>>> for obj in conn.object_store.objects("pictures".decode("utf8"),
                                         limit=100):
...     print obj
...
<100 Objects>
... another request transparently made to the Object Store service
<100 more Objects>

Getting Object Data 📥

Once you have an Object <#openstack.object_store.v1.obj.Object>, you get the data stored inside of it with the get_object_data() method.

>>> print ob.name
message.txt
>>> data = conn.object_store.get_object_data(ob)
>>> print data
Hello, world!

Additionally, if you want to save the object to disk, the download_object() convenience method takes an Object <#openstack.object_store.v1.obj.Object> and a path to write the contents to.

>>> conn.object_store.download_object(ob, "the_message.txt")

Uploading Objects 📤

Once you have data you'd like to store in the Object Store service, you use the upload_object() method. This method takes the data to be stored, along with at least an object name and the container it is to be stored in.

>>> hello = conn.object_store.upload_object(container="messages",
                                            name="helloworld.txt",
                                            data="Hello, world!")
>>> print hello
openstack.object_store.v1.container.Object: {'content-length': '0',
'container': u'messages', 'name': u'helloworld.txt',
'last-modified': 'Tue, 25 Nov 2014 17:39:29 GMT',
'etag': '5eb63bbbe01eeed093cb22bb8f5acdc3',
'x-trans-id': 'tx3035d41b03334aeaaf3dd-005474bed0',
'date': 'Tue, 25 Nov 2014 17:39:28 GMT',
'content-type': 'text/html; charset=UTF-8'}

Working with Object Metadata 🏷️✨

Working with metadata on objects is identical to how it's done with containers. You use the get_object_metadata() and set_object_metadata() methods.

The metadata attributes to be set can be found on the Object <#openstack.object_store.v1.obj.Object> object.

>>> secret.delete_after = 300
>>> secret = conn.object_store.set_object_metadata(secret)

We set the delete_after value to 500 seconds, causing the object to be deleted in 300 seconds, or five minutes. That attribute corresponds to the X-Delete-After header value, which you can see is returned when we retrieve the updated metadata.

Yes bestie, the original literally says 500 and 300 right there — both numbers stay. 🫶

>>> conn.object_store.get_object_metadata(ob)
openstack.object_store.v1.container.Object: {'content-length': '11',
'container': u'Secret Container',
'name': u'selfdestruct.txt', 'x-delete-after': 300,
'accept-ranges': 'bytes', 'last-modified': 'Tue, 25 Nov 2014 17:50:45 GMT',
'etag': '5eb63bbbe01eeed093cb22bb8f5acdc3',
'x-timestamp': '1416937844.36805',
'x-trans-id': 'tx5c3fd94adf7c4e1b8f334-005474c17b',
'date': 'Tue, 25 Nov 2014 17:50:51 GMT', 'content-type': 'text/plain'}

🎼 Using OpenStack Orchestration

Okay bestie, before you touch the Orchestration service you gotta make a connection to your cloud — follow the Connect <> user guide, and that's what hands you the conn variable used in all the examples below. No connection, no vibes. 💜

📑 Table of Contents

Working with Stacks
Software Configurations and Deployments

The Orchestration service creates and manages stacks — collections of resources described by a template — along with the software configurations and deployments applied to them. The examples below show a representative subset of what's possible; for the complete set of operations, see the Orchestration proxy reference <>. ✨

🏗️ Working with Stacks

To list the existing stacks, use the stacks() method, which returns a generator of Stack <#openstack.orchestration.v1.stack.Stack> objects:

>>> for stack in conn.orchestration.stacks():
...     print(stack.name, stack.status)

To create a stack from a template, use the create_stack() method:

>>> stack = conn.orchestration.create_stack(
...     name='my-stack',
...     template_url='https://example.com/template.yaml',
...     parameters={'key_name': 'my-key'})

To retrieve, update or delete a stack, use the get_stack(), update_stack() and delete_stack() methods. Each accepts either a stack ID or a Stack <#openstack.orchestration.v1.stack.Stack> instance:

>>> stack = conn.orchestration.get_stack(stack.id)
>>> conn.orchestration.delete_stack(stack)

You can validate a template before using it with validate_template(), and inspect the resources that make up a stack with resources(). Literally so helpful, ngl. 🔥

🧩 Software Configurations and Deployments

Software configurations and the deployments that apply them to servers are managed through the corresponding create_software_config / software_configs and create_software_deployment / software_deployments methods. Slay. 💅

🗂️ Using OpenStack Shared File Systems

Before working with the Shared File System service, you'll need to create a connection to your OpenStack cloud by following the Connect <> user guide. This will provide you with the conn variable used in the examples below. Same drill as always, bestie — get that conn first. 🫶

📑 Table of Contents

List Availability Zones
Share Instances
Get Share Instance
Reset Share Instance Status
Delete Share Instance
Resize Share
List Share Group Snapshots
Get Share Group Snapshot
List Share Group Snapshot Members
Create Share Group Snapshot
Reset Share Group Snapshot
Update Share Group Snapshot
Delete Share Group Snapshot
List Share Metadata
Get Share Metadata Item
Create Share Metadata
Update Share Metadata
Delete Share Metadata
Manage Share
Unmanage Share
List Share replicas
Create Share Replica
Get Share Replica
Delete Share Replica
Reset Status of Share Replica
Reset Replica State of Share Replica
Force Delete Share Replica
Promote Share Replica
Resync Share Replica

🌍 List Availability Zones

A Shared File System service availability zone is a failure domain for your shared file systems. You may create a shared file system (referred to simply as shares) in a given availability zone, and create replicas of the share in other availability zones. Spreading the love, as one does. 🌈

def list_availability_zones(conn):
    print("List Shared File System Availability Zones:")
    for az in conn.share.availability_zones():
        print(az)

Administrators can list, show information for, explicitly set the state of, and force-delete share instances. Admin kid energy, iykyk. 👑

def share_instances(conn, **query):
    print('List all share instances:')
    for si in conn.share.share_instances(**query):
        print(si)

Shows details for a single share instance.

def get_share_instance(conn, share_instance_id):
    print('Get share instance with given Id:')
    share_instance = conn.share.get_share_instance(share_instance_id)
    print(share_instance)

Explicitly updates the state of a share instance.

def reset_share_instance_status(conn, share_instance_id, status):
    print(
        'Reset the status of the share instance with the given '
        'share_instance_id to the given status'
    )
    conn.share.reset_share_instance_status(share_instance_id, status)

Force-deletes a share instance. Dramatic but effective.

def delete_share_instance(conn, share_instance_id):
    print('Force-delete the share instance with the given share_instance_id')
    conn.share.delete_share_instance(share_instance_id)

Shared File System shares can be resized (extended or shrunk) to a given size. For details on resizing shares, refer to the Manila docs <https://docs.openstack.org/manila/latest/user/create-and-manage-shares.html#extend-share>.

def resize_share(conn, share_id, share_size):
    # Be explicit about not wanting to use force if the share
    # will be extended.
    use_force = False
    print('Resize the share to the given size:')
    conn.share.resize_share(share_id, share_size, use_force)

def resize_shares_without_shrink(conn, min_size):
    # Sometimes, extending shares without shrinking
    # them (effectively setting a min size) is desirable.

    # Get list of shares from the connection.
    shares = conn.share.shares()

    # Loop over the shares:
    for share in shares:
        # Extend shares smaller than min_size to min_size,
        # but don't shrink shares larger than min_size.
        conn.share.resize_share(share.id, min_size, no_shrink=True)

A share group snapshot is a point-in-time, read-only copy of the data that is contained in a share group. You can list all share group snapshots — like a little time capsule of your data, obsessed. 🎀

def list_share_group_snapshots(conn, **query):
    print("List all share group snapshots:")
    share_group_snapshots = conn.share.share_group_snapshots(**query)
    for share_group_snapshot in share_group_snapshots:
        print(share_group_snapshot)

Show share group snapshot details.

def get_share_group_snapshot(conn, group_snapshot_id):
    print("Show share group snapshot with given Id:")
    share_group_snapshot = conn.share.get_share_group_snapshots(
        group_snapshot_id
    )
    print(share_group_snapshot)

Lists all share group snapshots members.

def share_group_snapshot_members(conn, group_snapshot_id):
    print("Show share group snapshot members with given Id:")
    members = conn.share.share_group_snapshot_members(group_snapshot_id)
    for member in members:
        print(member)

Creates a snapshot from a share group.

def create_share_group_snapshot(conn, share_group_id, **attrs):
    print("Creating a share group snapshot from given attributes:")
    share_group_snapshot = conn.share.create_share_group_snapshot(
        share_group_id, **attrs
    )
    print(share_group_snapshot)

Reset share group snapshot state.

def reset_share_group_snapshot_status(conn, group_snapshot_id, status):
    print("Reseting the share group snapshot status:")
    conn.share.reset_share_group_snapshot_status(group_snapshot_id, status)

Updates a share group snapshot.

def update_share_group_snapshot(conn, group_snapshot_id, **attrs):
    print("Updating a share group snapshot with given Id:")
    share_group_snapshot = conn.share.update_share_group_snapshot(
        group_snapshot_id, **attrs
    )
    print(share_group_snapshot)

Deletes a share group snapshot. Bye bestie, it was real. 👋

def delete_share_group_snapshot(conn, group_snapshot_id):
    print("Deleting a share group snapshot with given Id:")
    conn.share.delete_share_group_snapshot(group_snapshot_id)

Lists all metadata for a given share.

def list_share_metadata(conn, share_id):
    # Method returns the entire share with the metadata inside it.
    returned_share = conn.get_share_metadata(share_id)

    # Access metadata of share
    metadata = returned_share['metadata']

    print("List All Share Metadata:")
    for meta_key in metadata:
        print(f"{meta_key}={metadata[meta_key]}")

Retrieves a specific metadata item from a shares metadata by its key.

def get_share_metadata_item(conn, share_id, key):
    # Method returns the entire share with the metadata inside it.
    returned_share = conn.get_share_metadata_item(share_id, key)

    # Access metadata of share
    metadata = returned_share['metadata']

    print("Get share metadata item given item key and share id:")
    print(metadata[key])

Creates share metadata.

def create_share_metadata(conn, share_id, metadata):
    # Method returns the entire share with the metadata inside it.
    created_share = conn.create_share_metadata(share_id, metadata)

    # Access metadata of share
    metadata = created_share['metadata']

    print("Metadata created for given share:")
    print(metadata)

Updates metadata of a given share.

def update_share_metadata(conn, share_id, metadata):
    # Method returns the entire share with the metadata inside it.
    updated_share = conn.update_share_metadata(share_id, metadata, True)

    # Access metadata of share
    metadata = updated_share['metadata']

    print("Updated metadata for given share:")
    print(metadata)

Deletes a specific metadata item from a shares metadata by its key. Can specify multiple keys to be deleted.

def delete_share_metadata(conn, share_id, keys):
    # Method doesn't return anything.
    conn.delete_share_metadata(share_id, keys)

Manage a share with Manila.

Okay so the manage-share function wraps up like this — no cap, this is the part where you finally get the ID:

def manage_share(conn, protocol, export_path, service_host, **params):
    # Manage a share with the given protocol, export path, service host, and
    # optional additional parameters
    managed_share = conn.share.manage_share(
        protocol, export_path, service_host, **params
    )

    # Can get the ID of the share, which is now being managed with Manila
    managed_share_id = managed_share.id
    print("The ID of the share which was managed: %s", managed_share_id)

Unmanage a share from Manila. Bye-bye, management era 💅

def unmanage_share(conn, share_id):
    # Unmanage the share with the given share ID
    conn.share.unmanage_share(share_id)

    try:
        # Getting the share will raise an exception as it has been unmanaged
        conn.share.get_share(share_id)
    except Exception:
        pass

Share replicas are literally the replicated copies of the existing share. You can use Share Replicas to sync data so each share replica has an identical copy of the same share. Share replication can be a disaster recovery solution or a load sharing mirroring solution — iconic multitasking, fr fr ✨

def list_share_replicas(conn, **attrs):
    print("List share replicas for the shared file system:")
    for sr in conn.share.share_replicas(**attrs):
        print(sr)

Creates a share replica from attributes. New replica just dropped 🎀

def create_share_replica(conn, share_id, **attrs):
    print("Creating share replica:")
    share_replica = conn.share.create_share_replica(share_id, **attrs)
    print(share_replica)

List details of a single share replica. Gotta get that one specific replica, bestie 💖

def get_share_replica(conn, share_replica_id):
    print("Getting share replica with give Id:")
    share_replica = conn.share.share_replica(share_replica_id)
    print(share_replica)

Delete a share replica. It's giving cleanup era 🧹

def delete_share_replica(conn, share_replica_id):
    print("Deleting share replica with give Id:")
    conn.share.delete_share_replica(share_replica_id)

Reset status of the share replica. Fresh status, fresh vibes 🌈

def reset_status_share_replica(conn, share_replica_id, status):
    print("Resetting status for given share replica Id:")
    conn.share.share_replica_reset_status(share_replica_id, status)

Reset replica_state of the share replica. State reset supremacy 👑

def reset_replica_state_share_replica(conn, share_replica_id, reset_state):
    print("Resetting replica state for given share replica Id:")
    conn.share.share_replica_reset_replica_state(share_replica_id, reset_state)

Force-delete share replica. It is not subtle, and that's the point 😭

def force_delete_share_replica(conn, share_replica_id):
    print("Force deleting the share replica for the given Id:")
    conn.share.share_replica_force_delete(share_replica_id)

Promote share replica. Main character replica behavior, periodt ⭐

def promote_share_replica(conn, share_replica_id):
    print("Promoting share replica with given Id:")
    conn.share.share_replica_promote(share_replica_id)

Resync share replica. Sync it back into alignment, bestie 🫶

def resync_share_replica(conn, share_replica_id):
    print("Resyncing share replica with given Id:")
    conn.share.share_replica_resync(share_replica_id)

🧪 Testing 🧪

The SDK provides a number of utilities to help you test your applications. Test era, but make it cute 💖

🧪 Testing applications using OpenStack SDK 🧪

🎭 Fakes 🎭

The fakes module exists to help application developers using the OpenStack SDK unit test their applications. It provides a number of helper utilities to generate fake Resource and Proxy instances. These fakes do not require an established connection, and they let you validate that your application is using valid attributes and methods for both Resource and Proxy instances. Lowkey so useful 🎀

openstack.test.fakes.generate_fake_resource(resource_type, **attrs)

Generate a fake resource. Fake it till you make it, but make it type-correct ✨

Example usage:

>>> from openstack.compute.v2 import server
>>> from openstack.test import fakes
>>> fakes.generate_fake_resource(server.Server)
openstack.compute.v2.server.Server(...)

Parameters

resource_type — Object class.
attrs — Optional attributes to be set on resource.

Returns Instance of resource_type class populated with fake values of expected types.

Raises NotImplementedError — If a resource attribute specifies a type or list_type that cannot be automatically generated.

openstack.test.fakes.generate_fake_resources(resource_type, count=1, attrs=None)

Generate a given number of fake resource entities. A little generator full of fake besties 🌸

Example usage:

>>> from openstack.compute.v2 import server
>>> from openstack.test import fakes
>>> fakes.generate_fake_resources(server.Server, count=3)
<generator object generate_fake_resources at 0x7f075dc65040>

Parameters

resource_type — Object class.
count — Number of objects to return.
attrs — Attribute values to set into each instance.

Returns Generator of resource_type class instances populated with fake values of expected types.

openstack.test.fakes.generate_fake_proxy(service, api_version=None)

Generate a fake proxy for the given service type. Proxy methods whose return type annotation is a Resource subclass (or a Generator / optional thereof) are automatically configured to return fake resource instances via generate_fake_resource() or generate_fake_resources(). Return values can still be overridden on the returned mock after the fact. That's the autospec magic, iykyk 💅

Example usage:

>>> from openstack.compute import compute_service
>>> from openstack.compute.v2 import server
>>> from openstack.test import fakes
>>> fake_compute_proxy = fakes.generate_fake_proxy(
...    compute_service.ComputeService,
... )
>>> # get_server is pre-configured; returns a fake Server
>>> fake_server = fake_compute_proxy.get_server('some-uuid')
>>> isinstance(fake_server, server.Server)
True
>>> # servers() is pre-configured; yields fake Server instances
>>> fake_servers = list(fake_compute_proxy.servers())
>>> isinstance(fake_servers[0], server.Server)
True
>>> fake_compute_proxy.serverssss()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/usr/lib64/python3.11/unittest/mock.py", line 653, in __getattr__
    raise AttributeError("Mock object has no attribute %r" % name)
AttributeError: Mock object has no attribute 'serverssss'. Did you mean: 'server_ips'?

Parameters

service (ServiceDescription) — The service to generate the fake proxy for.
api_version (int or None) — The API version to generate the fake proxy for. This should be a major version and must be supported by openstacksdk, as specified in the supported_versions attribute of the provided service. This is only required if openstacksdk supports multiple API versions for the given service.

Raises ValueError — if the service is not a valid ServiceDescription or if api_version is not supported.

Returns An autospecced mock of the Proxy implementation for the specified service type and API version.

📚 API Documentation 📚

Service APIs are exposed through a two-layered approach. The classes exposed through our Connection interface are the place to start if you're an application developer consuming an OpenStack cloud. The Resource interface is the layer upon which the Connection is built, with Connection methods accepting and returning Resource objects.

The Cloud Abstraction layer has a data model.

🧬 Data Model 🧬

openstacksdk has a very strict policy on not breaking backwards compatibility ever. However, with the data structures returned from OpenStack, there are places where the resource structures from OpenStack are returned to the user somewhat directly, leaving an openstacksdk user open to changes/differences in result content. No cap, that's the risk 💀

To combat that, openstacksdk "normalizes" the return structure from OpenStack in many places, and the results of that normalization are listed below. Where openstacksdk performs normalization, a user can count on any fields declared in the docs as being completely safe to use — they are as much a part of openstacksdk's API contract as any other Python method. That's the good part 🫶

Some OpenStack objects allow for arbitrary attributes at the root of the object. openstacksdk will pass those through so as not to break anyone who may be counting on them, but as they are arbitrary openstacksdk can make no guarantees as to their existence. As part of normalization, openstacksdk will put any attribute from an OpenStack resource that is not in its data model contract into an attribute called properties. The contents of properties are defined to be an arbitrary collection of key value pairs with no promises as to any particular key ever existing.

If a user passes strict=True to the openstacksdk constructor, openstacksdk will not pass through arbitrary objects to the root of the resource, and will instead only put them in the properties dict. If a user is worried about accidentally writing code that depends on an attribute that is not part of the API contract, this can be a useful tool. Keep in mind all data can still be accessed via the properties dict, but any code touching anything in the properties dict should be aware that the keys found there are highly user/cloud specific. Any key that is transformed as part of the openstacksdk data model contract will not wind up with an entry in properties — only keys that are unknown.

📍 The location field 📍

A Location defines where a resource lives. It includes a cloud name and a region name, an availability zone as well as information about the project that owns the resource. Location lore, honestly 🗺️

The project info can be a project ID, or a combo of a project name plus a domain name or ID. If there's a project ID in there, bestie, just trust it — it's correct. 💯

Some resources are out here with zero ownership info. For those, we fill in the project info from the project your current token is for. (The token knows, okay? 🙈)

And some resources don't even have availability zone info, or they're just out here existing region-wide. Those get None as their availability zone. No zone, no drama. 🎀

Location = dict(
    cloud=str(),
    region_name=str(),
    zone=str() or None,
    project=dict(
        id=str() or None,
        name=str() or None,
        domain_id=str() or None,
        domain_name=str() or None,
    )
)

🫶 Connection Interface 🫶

A Connection instance is like, the main character of your cloud config. It holds your cloud config, your session, your auth info, and it gives you a whole set of higher-level interfaces to work with all your OpenStack services. Iconic behavior. 👑

✨ Connection ✨

The Connection class is the primary interface to the Python SDK. It keeps a context for a connection to a region of a cloud provider. And it has an attribute to access each OpenStack service — so you just vibe with conn.network, conn.compute, etc. 🌈

At minimum, bestie, the Connection class needs to be created with a config or the parameters to build one. That's non-negotiable.

The whole system is super flexible (it's giving ✨ adaptability ✨), but there are four main use cases for different ways to create a Connection:

Using config settings and keyword arguments as described in Configuring OpenStack SDK Applications <#openstack-config>
Using only keyword arguments passed to the constructor, ignoring config files and environment variables. (No outside noise, just vibes. 🙅‍♀️)
Using an existing authenticated keystoneauth1.session.Session, such as might exist inside of an OpenStack service operational context.
Using an existing CloudRegion <#openstack.config.cloud_region.CloudRegion>.

🛠️ Creating the Connection 🛠️

Using config settings

For users who want to create a Connection making use of named clouds in clouds.yaml files, OS_ environment variables, and Python keyword arguments, the openstack.connect() factory function is the recommended way to go. It's the moment. 💅

import openstack

conn = openstack.connect(cloud='example', region_name='earth1')

If the app in question is a command line application that should also accept command line arguments, an argparse.Namespace can be passed to openstack.connect() — it'll have relevant arguments added to it and then subsequently consumed by the constructor. So clean. ✨

import argparse
import openstack

options = argparse.ArgumentParser(description='Awesome OpenStack App')
conn = openstack.connect(options=options)

Using only keyword arguments

If the application wants to avoid loading any settings from clouds.yaml or environment variables, use the Connection constructor directly. As long as the cloud argument is omitted or None, the Connection constructor will not load settings from files or the environment. It literally minds its own business. 💁‍♀️

Note: This is a different default behavior than the connect() factory function. In connect() if cloud is omitted or None, a default cloud will be loaded, defaulting to the envvars cloud if it exists. (So like, connect() is nosy, Connection is chill. Different vibes entirely. 🫶)

from openstack import connection

conn = connection.Connection(
    region_name='example-region',
    auth={
        'auth_url': 'https://auth.example.com',
        'username': 'amazing-user',
        'password': 'super-secret-password',
        'project_id': '33aa1afc-03fe-43b8-8201-4e0d3b4b8ab5',
        'user_domain_id': '054abd68-9ad9-418b-96d3-3437bb376703',
    },
    compute_api_version='2',
    identity_interface='internal',
)

Per-service settings as needed by keystoneauth1.adapter.Adapter — like api_version, service_name, and interface — can be set, as seen above, by prefixing them with the official service-type name of the service. And region_name is a setting for the entire CloudRegion <#openstack.config.cloud_region.CloudRegion> and cannot be set per service. It's a whole-cloud mood, not a per-service one. fyi. 🌍

From existing authenticated Session

For applications that already have an authenticated Session, simply passing it to the Connection constructor is all that's needed. Easy. Slay. ✨

from openstack import connection

conn = connection.Connection(
    session=session,
    region_name='example-region',
    compute_api_version='2',
    identity_interface='internal',
)

From `oslo.conf` CONF object

For applications that have an oslo.config CONF object that has been populated with keystoneauth1.loading.register_adapter_conf_options in groups named by the OpenStack service's project name, it is possible to construct a Connection with the CONF object and an authenticated Session. Big brain energy. 🧠✨

Note: This is primarily intended for use by OpenStack services to talk amongst themselves. (It's giving internal group chat. 💬)

from keystoneauth1 import loading as ks_loading
from openstack import connection
from oslo_config import cfg

CONF = cfg.CONF

group = cfg.OptGroup('neutron')
ks_loading.register_session_conf_options(CONF, group)
ks_loading.register_auth_conf_options(CONF, group)
ks_loading.register_adapter_conf_options(CONF, group)

CONF()

auth = ks_loading.load_auth_from_conf_options(CONF, 'neutron')
sess = ks_loading.load_session_from_conf_options(
    CONF, 'neutron', auth=auth
)

conn = connection.Connection(
    session=sess,
    oslo_conf=CONF,
)

This can then be used with an appropriate configuration file. 📄

[neutron]
region_name = RegionOne
auth_strategy = keystone
project_domain_name = Default
project_name = service
user_domain_name = Default
password = password
username = neutron
auth_url = http://10.0.110.85/identity
auth_type = password
service_metadata_proxy = True
default_floating_pool = public

You may also wish to configure a service user. As discussed in the Keystone documentation <https://docs.openstack.org/keystone/latest/admin/manage-services.html>, service users are users with specific roles that identify the user as a service. The use of service users can avoid issues caused by the expiration of the original user's token during long running operations, as a fresh token issued for the service user will always accompany the user's token, which may have expired. (Long story short: your token might expire mid-operation and that's a whole mess. Service users fix that. 💅)

from keystoneauth1 import loading as ks_loading
from keystoneauth1 import service_token
from oslo_config import cfg
import openstack
from openstack import connection

CONF = cfg.CONF

neutron_group = cfg.OptGroup('neutron')
ks_loading.register_session_conf_options(CONF, neutron_group)
ks_loading.register_auth_conf_options(CONF, neutron_group)
ks_loading.register_adapter_conf_options(CONF, neutron_group)

service_group = cfg.OptGroup('service_user')
ks_loading.register_session_conf_options(CONF, service_group)
ks_loading.register_auth_conf_options(CONF, service_group)

CONF()
user_auth = ks_loading.load_auth_from_conf_options(CONF, 'neutron')
service_auth = ks_loading.load_auth_from_conf_options(CONF, 'service_user')
auth = service_token.ServiceTokenAuthWrapper(user_auth, service_auth)

sess = ks_loading.load_session_from_conf_options(
    CONF, 'neutron', auth=auth
)

conn = connection.Connection(
    session=sess,
    oslo_conf=CONF,
)

This will necessitate an additional section in the configuration file used. 👀

[service_user]
auth_strategy = keystone
project_domain_name = Default
project_name = service
user_domain_name = Default
password = password
username = nova
auth_url = http://10.0.110.85/identity
auth_type = password

From existing CloudRegion

If you already have an CloudRegion <#openstack.config.cloud_region.CloudRegion> you can pass it in instead. Reuse, recycle, slay. ♻️✨

from openstack import connection
import openstack.config

config = openstack.config.get_cloud_region(
    cloud='example',
    region_name='earth',
)
conn = connection.Connection(config=config)

💫 Using the Connection 💫

Services are accessed through an attribute named after the service's official service-type. So conn.identity, conn.network, conn.compute — it's giving organized. 🗂️

List

An iterator containing a list of all the projects is retrieved in this manner:

projects = conn.identity.projects()

Find or create

If you wanted to make sure you had a network named 'zuul', you would first try to find it and if that fails, you would create it. (Find-or-create: the "if not found, make it" of cloud resources. 🫶)

network = conn.network.find_network("zuul")
if network is None:
    network = conn.network.create_network(name="zuul")

Additional information about the services can be found in the Service Proxies <#service-proxies> documentation.

🌟 from_config 🌟

openstack.connection.from_config(cloud=None, config=None, options=None, **kwargs)

Create a Connection using openstack.config. It's the factory vibes.

Parameters

cloud (str) — Use the cloud configuration details when creating the Connection.
config (openstack.config.cloud_region.CloudRegion <#openstack.config.cloud_region.CloudRegion>) — An existing CloudRegion configuration. If no config is provided, openstack.config.OpenStackConfig will be called, and the provided name will be used in determining which cloud's configuration details will be used in creation of the Connection instance.
options (argparse.Namespace) — Allows direct passing in of options to be added to the cloud config. This does not have to be an actual instance of argparse.Namespace, despite the naming of the openstack.config.loader.OpenStackConfig.get_one argument to which it is passed. (Naming is just quirky like that, bestie. 🤷‍♀️)

Return type: Connection

👑 Connection Object 👑

class openstack.connection.Connection(cloud=None, config=None, session=None, app_name=None, app_version=None, extra_services=None, strict=False, use_direct_get=None, task_manager=None, rate_limit=None, oslo_conf=None, service_types=None, global_request_id=None, strict_proxies=False, pool_executor=None, **kwargs)

Create a connection to a cloud. Main character constructor energy. 💅

A connection needs information about how to connect, how to authenticate, and how to select the appropriate services to use. (The holy trinity of cloud vibes. ✨🌩️)

Okay so the recommended way to hand over this info is by referencing a named cloud config from an existing clouds.yaml file. The cloud name envvars may be used to consume a cloud configured via OS_ environment variables.

A pre-existing CloudRegion (openstack.config.cloud_region.CloudRegion) object can be passed in lieu of a cloud name, for cases where you already have a fully formed CloudRegion and literally just want to use it.

Similarly, if for some reason you already have a Session and want to use it, it may be passed in. 💖

Parameters

cloud (str) — Name of the cloud from config to use.
config (CloudRegion, i.e. openstack.config.cloud_region.CloudRegion) — CloudRegion object representing the config for the region of the cloud in question.
session (Session) — A session object compatible with Session.
app_name (str) — Name of the application to be added to User Agent.
app_version (str) — Version of the application to be added to User Agent.
extra_services — List of ServiceDescription (openstack.service_description.ServiceDescription) objects describing services that openstacksdk otherwise does not know about.
use_direct_get (bool) — For get methods, make specific REST calls for server-side filtering instead of making list calls and filtering client-side. Default false.
task_manager — Ignored. Exists for backwards compat during transition. Rate limit parameters should be passed directly to the rate_limit parameter.
rate_limit — Client-side rate limit, expressed in calls per second. The parameter can either be a single float, or it can be a dict with keys as service-type and values as floats expressing the calls per second for that service. Defaults to None, which means no rate-limiting is performed.
oslo_conf (ConfigOpts) — An oslo.config CONF object that has been populated with keystoneauth1.loading.register_adapter_conf_options in groups named by the OpenStack service's project name.
service_types — A list/set of service types this Connection should support. All other service types will be disabled (will error if used). Currently only supported in conjunction with the oslo_conf kwarg.
strict_proxies (bool) — Throw an openstack.exceptions.ServiceDiscoveryException if the endpoint for a given service doesn't work. This is useful for OpenStack services using sdk to talk to other OpenStack services where it can be expected that the deployer config is correct and errors should be reported immediately. Default false.
global_request_id (str) — A Request-id to send with all interactions.
pool_executor (Executor) — A futurist Executor object to be used for concurrent background activities. Defaults to None in which case a ThreadPoolExecutor will be created if needed.
kwargs — If a config is not provided, the rest of the parameters provided are assumed to be arguments to be passed to the CloudRegion constructor.

`add_service(service)`

Add a service to the Connection. ✨

Attaches an instance of the Proxy (openstack.proxy.Proxy) class contained in ServiceDescription (openstack.service_description.ServiceDescription). The Proxy (openstack.proxy.Proxy) will be attached to the Connection by its service_type and by any aliases that may be specified.

Parameters

service (openstack.service_description.ServiceDescription from openstack.service_description.ServiceDescription) — Object describing the service to be attached. As a convenience, if service is a string it will be treated as a service_type and a basic ServiceDescription (openstack.service_description.ServiceDescription) will be created.

`authorize()`

Authorize this Connection 👑

Note: This method is optional. When an application makes a call to any OpenStack service, this method allows you to request a token manually before attempting to do anything else.

Returns — A string token.

Raises HttpException (openstack.exceptions.HttpException) if the authorization fails due to reasons like the credentials provided are unable to be authorized or the auth_type argument is missing, etc.

`connect_as(**kwargs)`

Make a new Connection object with new auth context.

Take the existing settings from the current cloud and construct a new Connection object with some of the auth settings overridden. This is useful for getting an object to perform tasks with as another user, or in the context of a different project.

conn = openstack.connect(cloud='example')
# Work normally
servers = conn.list_servers()
conn2 = conn.connect_as(username='different-user', password='')
# Work as different-user
servers = conn2.list_servers()

Parameters

kwargs — keyword arguments can contain anything that would normally go in an auth dict. They will override the same settings from the parent cloud as appropriate. Entries that do not want to be overridden can be ommitted.

`connect_as_project(project)`

Make a new Connection object with a new project.

Take the existing settings from the current cloud and construct a new Connection object with the project settings overridden. This is useful for getting an object to perform tasks with as another user, or in the context of a different project.

cloud = openstack.connect(cloud='example')
# Work normally
servers = cloud.list_servers()
cloud2 = cloud.connect_as_project('different-project')
# Work in different-project
servers = cloud2.list_servers()

Parameters

project — Either a project name or a project dict as returned by list_projects.

`endpoint_for(service_type, interface=None, region_name=None)`

Return the endpoint for a given service. 🦋

Respects config values for Connection, including *_endpoint_override. For direct values from the catalog regardless of overrides, see get_endpoint_from_catalog() (openstack.config.cloud_region.CloudRegion.get_endpoint_from_catalog).

Parameters

service_type — Service Type of the endpoint to search for.
interface — Interface of the endpoint to search for. Optional, defaults to the configured value for interface for this Connection.
region_name — Region Name of the endpoint to search for. Optional, defaults to the configured value for region_name for this Connection.

Returns — The endpoint of the service, or None if not found.

`add_auto_ip(server, wait=False, timeout=60, reuse=True)`

Add a floating IP to a server. 🌈

This method is intended for basic usage. For advanced network architecture (e.g. multiple external networks or servers with multiple interfaces), use other floating IP methods.

This method can reuse available IPs, or allocate new IPs to the current project.

Parameters

server — a server dictionary.
reuse — Whether or not to attempt to reuse IPs, defaults to True.
wait — (optional) Wait for the address to appear as assigned to the server. Defaults to False.
timeout — (optional) Seconds to wait, defaults to 60. See the wait parameter.
reuse — Try to reuse existing ips. Defaults to True.

yes bestie, reuse is listed twice in the source — both stay, no cap 💅

Returns — Floating IP address attached to server.

`add_flavor_access(flavor_id, project_id)`

Grant access to a private flavor for a project/tenant.

Parameters

flavor_id (string) — ID of the private flavor.
project_id (string) — ID of the project/tenant.

Returns — None

Raises SDKException (openstack.exceptions.SDKException) on operation error.

`add_host_to_aggregate(name_or_id, host_name)`

Add a host to an aggregate.

Parameters

name_or_id — Name or ID of the host aggregate.
host_name — Host to add.

Raises SDKException (openstack.exceptions.SDKException) on operation error.

`add_ip_list(server, ips, wait=False, timeout=60, fixed_address=None, nat_destination=None)`

Attach a list of IPs to a server.

Parameters

server — a server object
ips — list of floating IP addresses or a single address ✨
wait — (optional) wait for the address to appear as assigned to the server. Defaults to False. 🕰️
timeout — (optional) seconds to wait, defaults to 60. See the wait parameter. ⏳
fixed_address — (optional) fixed address of the server to attach the IP to
nat_destination — (optional) name or ID of the network that the fixed IP to attach the floating IP should be on 🌐

Returns: the updated server — openstack.compute.v2.server.Server 💖

Raises: SDKException <#openstack.exceptions.SDKException> on operation error.

`add_router_interface(router, subnet_id=None, port_id=None)`

Attach a subnet to an internal router interface. 🛰️

You gotta specify either a subnet ID or a port ID for the internal interface. Supply both and boom — that's an error. No mixing, bestie.

Parameters

router (dict) — the dict object of the router being changed
subnet_id (string) — the ID of the subnet to use for the interface
port_id (string) — the ID of the port to use for the interface

Returns: the raw response body from the request. 📦

Raises: SDKException <#openstack.exceptions.SDKException> on operation error.

`add_server_security_groups(server, security_groups)`

Add security groups to a server. 🔐

Add existing security groups to an existing server. If the security groups are already present on the server, this will continue unaffected. So like… no drama, it just keeps going.

Parameters

server — the server to remove security groups from. (Yep, the page literally says “remove” here — not me being chaotic 💀)
security_groups — a list of security groups to remove.

Returns: False if server or security groups are undefined, True otherwise.

Raises: SDKException <#openstack.exceptions.SDKException> on operation error.

`add_user_to_group(name_or_id, group_name_or_id)`

Add a user to a group. 👯

Parameters

name_or_id — name or unique ID of the user.
group_name_or_id — group name or ID.

Raises: SDKException <#openstack.exceptions.SDKException> if something goes wrong during the OpenStack API call.

`add_volume_type_access(name_or_id, project_id)`

Grant access on a volume_type to a project. 🎟️

NOTE: the call works even if the project does not exist. Yes, really. The page said it, I'm just repeating it.

Parameters

name_or_id — ID or name of a volume_type
project_id — a project id

Returns: None

Raises: SDKException <#openstack.exceptions.SDKException> on operation error.

`attach_port_to_machine(name_or_id, port_name_or_id)`

Attach a virtual port to the bare metal machine. 🖥️✨

Parameters

name_or_id (string) — a machine name or UUID.
port_name_or_id (string) — a port name or UUID. Note that this is a Network service port, not a bare metal NIC. Important distinction, bestie 🫶

Returns: Nothing.

`attach_volume(server, volume, device=None, wait=True, timeout=None)`

Attach a volume to a server. 💽

This will attach a volume, described by the passed-in volume dict (as returned by get_volume()), to the server described by the passed-in server dict (as returned by get_server()) on the named device on the server.

If the volume is already attached to the server, or generally not available, then an exception is raised. To re-attach to a server, but under a different device, the user must detach it first. No sneaky double-attach, okay? 😭

Parameters

server — the server dict to attach to.
volume — the volume dict to attach.
device — the device name where the volume will attach.
wait — if true, waits for volume to be attached.
timeout — seconds to wait for volume attachment. None is forever.

Returns: a volume attachment object.

Raises: ResourceTimeout <#openstack.exceptions.ResourceTimeout> if wait time exceeded.

Raises: SDKException <#openstack.exceptions.SDKException> on operation error.

`available_floating_ip(network=None, server=None)`

Get a floating IP from a network or a pool. 🌊

Return the first available floating IP or allocate a new one.

Parameters

network — name or ID of the network.
server — server the IP is for if known

Returns: a (normalized) structure with a floating IP address description.

`bind_accelerator_request(uuid, properties)`

Bind an accelerator to VM. ⚡

A deprecated alias for patch_accelerator_request. 🚨 Deprecated alert, bestie — it's giving “old route, still works, don’t make it your whole personality.”

`close()`

Release any resources held open. 🧹✨

`create_accelerator_request(attrs)`

Create an accelerator_request. 🚀

Parameters

attrs — the info of accelerator_request to be created.

Returns: an accelerator AcceleratorRequest object.

`create_aggregate(name, availability_zone=None)`

Create a new host aggregate. 🏗️

Parameters

name — name of the host aggregate being created
availability_zone — availability zone to assign hosts

Returns: the created compute Aggregate object.

Raises: SDKException <#openstack.exceptions.SDKException> on operation error.

`create_cluster_template(name, image_id=None, keypair_id=None, coe=None, **kwargs)`

Create a cluster template. 🧩

Parameters

name (string) — name of the cluster template.
image_id (string) — name or ID of the image to use.
keypair_id (string) — name or ID of the keypair to use.
coe (string) — name of the coe for the cluster template. Other arguments will be passed in kwargs.

Returns: a dict containing the cluster template description

Raises: SDKException <#openstack.exceptions.SDKException> if something goes wrong during the OpenStack API call

`create_coe_cluster(name, cluster_template_id, **kwargs)`

Create a COE cluster based on given cluster template. 🐳

Parameters

name (string) — name of the cluster.
cluster_template_id (string) — ID of the cluster template to use.
kwargs (dict) — any other arguments to pass in.

Returns: the created container infrastructure management Cluster object.

Raises: SDKException <#openstack.exceptions.SDKException> if something goes wrong during the OpenStack API call

`create_container(name, public=False)`

Create an object-store container. 🗃️

Parameters

name (str) — name of the container to create.
public (bool) — whether to set this container to be public. Defaults to False.

Returns: the created object store Container object.

`create_device_profile(attrs)`

Create a device_profile. 🧬

Parameters

attrs — the info of device_profile to be created.

Returns: an accelerator DeviceProfile objects.

`create_directory_marker_object(container, name, **headers)`

Create a zero-byte directory marker object. 📁✨

Note: this method is not needed in most cases. Modern swift does not require directory marker objects. However, some swift installs may need these.

When using swift Static Web and Web Listings to serve static content one may need to create a zero-byte object to represent each “directory”. Doing so allows Web Listings to generate an index of the objects inside of it, and allows Static Web to render index.html “files” that are “inside” the directory.

Parameters

container — the name of the container.
name — name for the directory marker object within the container.
headers — these will be passed through to the object creation API as HTTP Headers.

Returns: the created object store Object object.

`create_domain(name, description=None, enabled=True)`

Create a domain. 👑

Parameters

name — the name of the domain.
description — a description of the domain.
enabled — is the domain enabled or not (defaults to True) ✨

Returns — the created identity Endpoint object 💖

Raises SDKException if the domain cannot be created 😭

`create_endpoint(service_name_or_id, url=None, interface=None, region=None, enabled=True, **kwargs)`

okay so this one makes a Keystone endpoint — the actual addressable thing your service lives at 🔥

Parameters

service_name_or_id — service name or id this endpoint belongs to 🎀
url — URL of the endpoint
interface — interface type of the endpoint
public_url — the endpoint's public URL 🌈
internal_url — the endpoint's internal URL
admin_url — the endpoint's admin URL 👑
region — endpoint region
enabled — whether the endpoint is enabled or not

Returns — a list of identity Endpoint objects 💅

Raises SDKException if the service can't be found, or if something goes sideways during the OpenStack API call 💀

`create_endpoint_group(name, filters, description=None)`

creates a Keystone endpoint group, no cap 🫶

Parameters

name — the name of the endpoint group 🌸
description — the description of the endpoint group
filters — describes the filtering performed by the endpoint group 🔍

Returns — an identity EndpointGroup object ✨

Raises SDKException if the endpoint group cannot be created 😭

`create_firewall_group(**kwargs)`

creates a firewall group 🧱 Two things worth knowing: the keys egress_firewall_policy and ingress_firewall_policy get looked up and mapped to egress_firewall_policy_id and ingress_firewall_policy_id respectively, and the port name-or-ids list gets turned into a list of port ids before the POST request goes out. iykyk 💅

Parameters

admin_state_up (bool) — state of the firewall group. Setting it to False will block all traffic. Defaults to True ⚠️
description — human-readable description
egress_firewall_policy — name or id of the egress firewall policy
ingress_firewall_policy — name or id of the ingress firewall policy
name — human-readable name 🎀
ports (list[str]) — list of associated ports (name or id)
project_id — project id
shared — visibility to other projects. Defaults to False 🦋

Raises BadRequestException if parameters are malformed

Raises DuplicateResource on multiple matches 👀

Raises NotFoundException if the (ingress-, egress-) firewall policy or a port is not found 💀

Returns — the created network FirewallGroup object 💖

`create_firewall_policy(**kwargs)`

creates a firewall policy, iconic behaviour honestly 🌟

Parameters

audited (bool) — status of audition of firewall policy. It gets set to False every time the firewall policy or its associated firewall rules are changed, and it has to be explicitly set back to True 🙈
description — human-readable description
firewall_rules (list[str]) — list of associated firewall rules
name — human-readable name
project_id — project id
shared (bool) — visibility to other projects. Defaults to False ✨

Raises BadRequestException if parameters are malformed

Raises NotFoundException if a resource from firewall_list isn't found 😭

Returns — the created network FirewallPolicy object 🫶

`create_firewall_rule(**kwargs)`

creates a firewall rule — this is the one with the most knobs, lowkey a lot 🎛️

Parameters

action — action performed on traffic. Valid values: allow, deny. Defaults to deny ⚠️
description — human-readable description
destination_firewall_group_id — id of the destination firewall group
destination_ip_address — IPv4-, IPv6 address or CIDR
destination_port — port or port range (e.g. 80:90)
enabled (bool) — status of the firewall rule. you can disable rules without disassociating them from firewall policies. Defaults to True 💅
ip_version (int) — IP version. Valid values: 4, 6. Defaults to 4
name — human-readable name 🌸
project_id — project id
protocol — IP protocol. Valid values: icmp, tcp, udp, null
shared (bool) — visibility to other projects. Defaults to False
source_firewall_group_id — id of the source firewall group
source_ip_address — IPv4-, IPv6 address or CIDR
source_port — port or port range (e.g. 80:90) 🔥

Raises BadRequestException if parameters are malformed

Returns — the created network FirewallRule object 💖

`create_flavor(name, ram, vcpus, disk, description=None, flavorid='auto', ephemeral=0, swap=0, rxtx_factor=1.0, is_public=True)`

creates a brand new flavor, the blueprint for your servers 🎀

Parameters

name — descriptive name of the flavor
ram — memory in MB for the flavor
vcpus — number of VCPUs for the flavor
disk — size of local disk in GB 💾
description — description of the flavor
flavorid — id for the flavor (optional)
ephemeral — ephemeral space size in GB
swap — swap space in MB
rxtx_factor — RX/TX factor
is_public — make the flavor accessible to the public 🌈

Returns — the created compute Flavor object ✨

Raises SDKException on operation error 😭

`create_floating_ip(network=None, server=None, fixed_address=None, nat_destination=None, port=None, wait=False, timeout=60)`

allocates a new floating IP from a network or a pool 🌊 so glamorous of it

Parameters

network — name or ID of the network the floating IP should come from
server — (optional) server dict for the server to create the IP for and to which it should be attached
fixed_address — (optional) fixed IP to attach the floating IP to
nat_destination — (optional) name or ID of the network that the fixed IP to attach the floating IP to should be on
port — (optional) the port ID the floating IP should be attached to. heads up: specifying a port conflicts with specifying a server, fixed_address or nat_destination ⚠️
wait — (optional) whether to wait for the IP to be active. Defaults to False. Only applies if a server is provided
timeout — (optional) how long to wait for the IP to be active. Defaults to 60. Only applies if a server is provided ⏳

Returns — a floating IP address 💅

Raises SDKException on operation error 💀

`create_group(name, description, domain=None)`

creates a group 👯‍♀️ literally the friend group of identity objects

Parameters

name (string) — group name
description (string) — group description
domain (string) — domain name or ID for the group 🌸

Returns — an identity Group object 🫶

Raises SDKException if something goes wrong during the OpenStack API call 😭

`create_image(name, filename=None, container=None, md5=None, sha256=None, disk_format=None, container_format=None, disable_vendor_agent=True, wait=False, timeout=3600, tags=None, allow_duplicates=False, meta=None, volume=None, **kwargs)`

uploads an image 🖼️ main character energy fr fr

Parameters

name (str) — name of the image to create. if it's a pathname of an image, the name will be constructed from the extensionless basename of the path ✨
filename (str) — the path to the file to upload, if needed (optional, defaults to None)
container (str) — name of the container in swift where images should be uploaded for import if the cloud requires such a thing (optional, defaults to 'images') 🦋
md5 (str) — md5 sum of the image file. if it's not given, an md5 will be calculated 🔍

and there's more params where that came from, don't you worry bestie 💅

sha256 (str) — the sha256 sum of the image file. If you don't pass it, an md5 gets calculated instead. 💅
- disk_format (str) — which disk format the image is in. (optional, and it defaults to the os-client-config config value for this cloud)
- container_format (str) — the container format the image is in. (optional, defaults to the os-client-config config value for this cloud, same deal)
- tags (list) — the list of tags for this image. Every tag is a string of at most 255 chars. ✨
- disable_vendor_agent (bool) — whether or not to append metadata flags to the image so the cloud in question knows not to expect a vendor agent to be running. (optional, defaults to True)
- wait (bool) — if true, it waits for the image to be created. Defaults to true — but heads up bestie, one of the upload methods is always synchronous, so like… yeah. 😭
- timeout — seconds to wait for image creation. None is forever.
- allow_duplicates — if true, it skips the checks that enforce unique image name. (optional, defaults to False)
- meta — a dict of key/value pairs to use for metadata that bypasses automatic type conversion.
- volume — name or ID or volume object of a volume to create an image from. Mutually exclusive with (optional, defaults to None)

Additional kwargs will be passed to the image creation as additional metadata for the image, and every value gets converted to string — except for min_disk, min_ram, size and virtual_size, which get converted to int. 🧮

So if you're 100% sure all your data types are correct, or you have some advanced need to be explicit, use meta. If you're just a normal consumer, passing kwargs is probably the move. 🫶

And if a value shows up in both meta and kwargs — meta wins. periodt.

Returns An image openstack.image.v2.image.Image <#openstack.image.v2.image.Image> object.

Raises SDKException <#openstack.exceptions.SDKException> if there are problems uploading.

`create_image_snapshot(name, server, wait=False, timeout=3600, **metadata)`

Create an image by snapshotting an existing server. 📸

note: on most clouds this is a cold snapshot — meaning the server in question will be shut down before the snapshot is taken. It's possible that it's a live snapshot, but there is literally no way to know as a user, so caveat emptor. 💀

Parameters

name — name of the image to be created
server — server name or ID or dict representing the server to be snapshotted
wait — if true, waits for image to be created.
timeout — seconds to wait for image creation. None is forever.
metadata — metadata to give the newly-created image entity

Returns The created image Image object. 👑

Raises SDKException <#openstack.exceptions.SDKException> if there are problems uploading.

`create_keypair(name, public_key=None)`

Create a new keypair. 🔑✨

Parameters

name — name of the keypair being created.
public_key — public key for the new keypair.

Returns The created compute Keypair object.

Raises SDKException <#openstack.exceptions.SDKException> on operation error.

`create_network(name, shared=False, admin_state_up=True, external=False, provider=None, project_id=None, availability_zone_hints=None, port_security_enabled=None, mtu_size=None, dns_domain=None)`

Create a network. 🌐

Parameters

name (string) — name of the network being created.
shared (bool) — set the network as shared.
admin_state_up (bool) — set the network administrative state to up.
external (bool) — whether this network is externally accessible.
provider (dict) — a dict of network provider options. Example:

{'network_type': 'vlan', 'segmentation_id': 'vlan1'}

project_id (string) — specify the project ID this network will be created on (admin-only). 👀
availability_zone_hints (types.ListType) — a list of availability zone hints.
port_security_enabled (bool) — enable / disable port security
mtu_size (int) — maximum transmission unit value to address fragmentation. Minimum value is 68 for IPv4, and 1280 for IPv6.
dns_domain (string) — specify the DNS domain associated with this network.

Returns The created network Network object.

Raises SDKException <#openstack.exceptions.SDKException> on operation error.

`create_object(container, name, filename=None, md5=None, sha256=None, segment_size=None, use_slo=True, metadata=None, generate_checksums=None, data=None, **headers)`

Create a file object. 🗂️

Automatically uses large-object segments if needed — she's smart like that.

Parameters

container — the name of the container to store the file in. This container will be created if it doesn't exist already.
name — name for the object within the container.
filename — the path to the local file whose contents will be uploaded. Mutually exclusive with data.
data — the content to upload to the object. Mutually exclusive with filename.
md5 — a hexadecimal md5 of the file. (Optional) if it's known and you can pass it here, it saves repeating the expensive md5 process. It's assumed to be accurate.
sha256 — a hexadecimal sha256 of the file. (Optional) see md5.
segment_size — break the uploaded object into segments of this many bytes. (Optional) Shade will attempt to discover the maximum value for this from the server if it isn't specified, or will use a reasonable default.
headers — these will be passed through to the object creation API as HTTP Headers.
use_slo — if the object is large enough to need to be a Large Object, use a static rather than dynamic object. Static Objects will delete segment objects when the manifest object is deleted. (optional, defaults to True)
generate_checksums — whether to generate checksums on the client side that get added to headers, for later prevention of double uploads of identical data. (optional, defaults to True)
metadata — this dict will get changed into headers that set metadata of the object

Returns The created object store Object object.

Raises SDKException <#openstack.exceptions.SDKException> on operation error.

`create_port(network_id, **kwargs)`

Create a port. 🔌

Parameters

network_id — the ID of the network. (Required)
name — a symbolic name for the port. (Optional)
admin_state_up — the administrative status of the port, which is up (true, default) or down (false). (Optional)
mac_address — the MAC address. (Optional)
fixed_ips — list of ip_addresses and subnet_ids. See subnet_id and ip_address. (Optional) For example:

[
    {
        "ip_address": "10.29.29.13",
        "subnet_id": "a78484c4-c380-4b47-85aa-21c51a2d8cbd",
    },
    ...,
]

where

subnet_id: If you specify only a subnet
       ID,
               OpenStack Networking allocates an
               available IP from that subnet to
               the port.

ip_address: (Optional) If you specify both
a subnet ID and
               an IP address, OpenStack Networking
               tries to allocate the specified
               address to the port.

security_groups — list of security group UUIDs. (Optional)
allowed_address_pairs — allowed address pairs list (Optional) For example:

extra_dhcp_opts — extra DHCP options, optional bestie. Like this:

[{"opt_name": "opt name1", "opt_value": "value1"}, ...]

device_owner — the ID of the entity that uses this port. Think a DHCP agent, that kind of thing. (Optional)
device_id — the ID of the device using this port, like a virtual server. (Optional)
vnic_type (binding) — the type of the port we're creating. (Optional)
port_security_enabled — the security port state that gets created on the network. (Optional)
qos_policy_id — the ID of the QoS policy you want applied to this port. (Optional)
project_id — which project the port lives in. (Optional)
description — a lil description of the port. (Optional)
dns_domain — the DNS domain relevant for the port. (Optional)
dns_name — the DNS name of the port. (Optional)
numa_affinity_policy — the numa affinity policy, honestly. Can be "None", "required", "preferred" or "legacy". (Optional)
propagate_uplink_status — whether the uplink status of the port should be propagated. (Optional)
mac_learning_enabled — whether mac learning should be enabled on the port. (Optional)

Returns — the created network Port object. 🎀

Raises — SDKException <#openstack.exceptions.SDKException> on operation error. 😭

`create_project(name, domain_id, description=None, enabled=True, **kwargs)`

Create a project. Slay, an org chart in code form. ✨

Parameters

name
domain_id
description
enabled

Returns — an identity Project object. 💜

`create_qos_bandwidth_limit_rule(policy_name_or_id, max_kbps, **kwargs)`

Create a QoS bandwidth limit rule. Speed limits but make it cloud. 🔥

Parameters

policy_name_or_id (string) — name or ID of the QoS policy this rule should be attached to.
max_kbps (int) — the maximum bandwidth limit value, in kilobits per second.
max_burst_kbps (int) — the maximum burst value, in kilobits.
direction (string) — ingress or egress. Basically: which way is the traffic getting limited.

Returns — the created network QoSBandwidthLimitRule object. ✨

Raises — SDKException <#openstack.exceptions.SDKException> on operation error.

`create_qos_dscp_marking_rule(policy_name_or_id, dscp_mark)`

Create a QoS DSCP marking rule. Fancy packet-labeling behaviour, we love to see it. 🎀

Parameters

policy_name_or_id (string) — name or ID of the QoS policy this rule should be attached to.
dscp_mark (int) — the DSCP mark value.

Returns — the created network QoSDSCPMarkingRule object.

Raises — SDKException <#openstack.exceptions.SDKException> on operation error.

`create_qos_minimum_bandwidth_rule(policy_name_or_id, min_kbps, **kwargs)`

Create a QoS minimum bandwidth limit rule. The floor, not the ceiling, bestie. 🦋

Parameters

policy_name_or_id (string) — name or ID of the QoS policy this rule should be attached to.
min_kbps (int) — the minimum bandwidth value, in kilobits per second.
direction (string) — ingress or egress. The direction in which the traffic will be available.

Returns — the created network QoSMinimumBandwidthRule object.

Raises — SDKException <#openstack.exceptions.SDKException> on operation error.

`create_qos_policy(**kwargs)`

Create a QoS policy. The whole vibe container for the rules above. 👑

Parameters

name (string) — the name of the QoS policy being created.
description (string) — description of the created QoS policy.
shared (bool) — set the QoS policy as shared.
default (bool) — set the QoS policy as the default for the project.
project_id (string) — specify the project ID this QoS policy will be created on (admin-only).

Returns — the created network QosPolicy object.

Raises — SDKException <#openstack.exceptions.SDKException> on operation error.

`create_recordset(zone, name, recordset_type, records, description=None, ttl=None)`

Create a recordset. DNS but make it an accessory. 💅

Parameters

zone — name, ID or openstack.dns.v2.zone.Zone <#openstack.dns.v2.zone.Zone> instance of the zone managing the recordset.
name — name of the recordset.
recordset_type — type of the recordset.
records — list of the recordset definitions.
description — description of the recordset.
ttl — TTL value of the recordset.

Returns — a dict representing the created recordset.

Raises — SDKException <#openstack.exceptions.SDKException> on operation error.

`create_role(name, **kwargs)`

Create a Keystone role. Permissions era. 🌈

Parameters

name (string) — the name of the role.
domain_id — domain id (v3).

Returns — an identity Role object.

Raises — SDKException <#openstack.exceptions.SDKException> if the role cannot be created.

`create_router(name=None, admin_state_up=True, ext_gateway_net_id=None, enable_snat=None, ext_fixed_ips=None, project_id=None, availability_zone_hints=None)`

Create a logical router. The main character of your network topology, fr. 🚦

Parameters

name (string) — the router name.
admin_state_up (bool) — the administrative state of the router.
ext_gateway_net_id (string) — network ID for the external gateway.
enable_snat (bool) — enable the Source NAT (SNAT) attribute.
ext_fixed_ips — list of dictionaries of the desired IP and/or subnet on the external network. Example:

[
    {
        "subnet_id": "8ca37218-28ff-41cb-9b10-039601ea7e6b",
        "ip_address": "192.168.10.2",
    }
]

project_id (string) — project ID for the router.
availability_zone_hints (types.ListType) — a list of availability zone hints.

Returns — the created network Router object.

Raises — SDKException <#openstack.exceptions.SDKException> on operation error.

`create_security_group(name, description, project_id=None, stateful=None)`

Create a new security group. Your little velvet rope for traffic. 🎀

Parameters

name (string) — a name for the security group.
description (string) — describes the security group.
project_id (string) — specify the project ID this security group will be created on (admin-only).
stateful (string) — whether the security group is stateful or not.

Returns — a openstack.network.v2.security_group.SecurityGroup representing the new security group.

Raises — SDKException <#openstack.exceptions.SDKException> on operation error.

Raises — OpenStackCloudUnavailableFeature if security groups are not supported on this cloud. 😭 Rough.

`create_security_group_rule(secgroup_name_or_id, port_range_min=None, port_range_max=None, protocol=None, remote_ip_prefix=None, remote_group_id=None, remote_address_group_id=None, direction='ingress', ethertype='IPv4', project_id=None, description=None)`

Create a new security group rule. The actual individual rules of the velvet rope. 💅

Parameters

secgroup_name_or_id (string) — the security group name or ID to associate with this security group rule. Heads up: if you hand it a non-unique group name, an exception is raised.
port_range_min (int) — the minimum port number in the range matched by the security group rule. If the protocol is TCP or UDP, this value must be less than or equal to the port_range_max attribute value. And like, if nova is used by the cloud provider for security groups, then a value of None will be transformed to -1.
port_range_max (int) — the biggest port number in the range this security group rule matches 💅 real talk: port_range_min is the one that constrains port_range_max. And if your cloud provider uses nova for security groups, then a value of None gets transformed into -1. iykyk.
- protocol (string) — the protocol this security group rule matches. Valid values are None, tcp, udp, and icmp. that's the whole list, bestie, don't get creative 🎀
- remote_ip_prefix (string) — the remote IP prefix to associate with this security group rule. This attribute matches the specified IP prefix as the source IP address of the IP packet. it's giving "who's allowed in" energy ✨
- remote_group_id (string) — the remote group ID to associate with this security group rule.
- remote_address_group_id (string) — the remote address group ID to associate with this security group rule.
- direction (string) — ingress or egress: the direction in which the security group rule is applied. For a compute instance, an ingress security group rule is applied to incoming (ingress) traffic for that instance. An egress rule is applied to traffic leaving the instance. so ingress = coming in, egress = heading out 🦋
- ethertype (string) — must be IPv4 or IPv6, and addresses represented in CIDR must match the ingress or egress rules. no mixing, no matching, periodt.
- project_id (string) — specify the project ID this security group will be created on (admin-only). 👑 admin only, so if that's not you, this one's not for you.
- description (string) — description of the rule, max 255 characters.

Parameters

name — name of the stack.
tags — list of tag(s) of the stack. (optional)
template_file — path to the template.
template_url — URL of template.
template_object — URL to retrieve template object.

files — a dict of extra file content you wanna include 📁
rollback — turn on rollback if the create fails (yes queen, safety net)
wait — whether to wait for the delete to finish
timeout — stack create timeout, counted in seconds ⏱️
environment_files — paths to the environment files you want applied

Any other arguments you throw in get passed along as stack parameters, and those take precedence over anything those same parameters say inside the environments. Lowkey important, bestie.

Only one of template_file, template_url, template_object should be specified. Pick one. Just one. 💅

Returns — a dict holding the stack description

Raises — SDKException (as in openstack.exceptions.SDKException) if something goes sideways during the OpenStack API call 😭

`create_subnet`

create_subnet(network_name_or_id, cidr=None, ip_version=4,
enable_dhcp=False, subnet_name=None, tenant_id=None,
allocation_pools=None, gateway_ip=None, disable_gateway_ip=False,
dns_nameservers=None, host_routes=None, ipv6_ra_mode=None,
ipv6_address_mode=None, prefixlen=None,
use_default_subnetpool=False, subnetpool_name_or_id=None,
**kwargs)

Make a subnet on a network you already picked out. Slay 🦋

Parameters

network_name_or_id (string) — the unique name or ID of the attached network. Heads up: if the name you give isn't unique, it raises an exception 🙈
cidr (string) — the CIDR. Only one of cidr, use_default_subnetpool and subnetpool_name_or_id can be specified at the same time. One. Not two. Not three.
ip_version (int) — the IP version, and it's either 4 or 6
enable_dhcp (bool) — set to True if DHCP is enabled and False if it's disabled. Default is False.
subnet_name (string) — the name of the subnet
tenant_id (string) — the ID of the tenant that owns the network. Only admin users can hand out a tenant ID that isn't their own 👑
allocation_pools — a list of dictionaries with the start and end addresses for the allocation pools. Like, for example:

[{"start": "192.168.199.2", "end": "192.168.199.254"}]

gateway_ip (string) — the gateway IP address. When you specify both allocation_pools and gateway_ip, you must make sure the gateway IP doesn't overlap with the allocation pools you gave. No overlap, no drama 💀
disable_gateway_ip (bool) — set to True if the gateway IP address is disabled and False if it's enabled. It is not allowed alongside gateway_ip. Default is False.
dns_nameservers — a list of DNS name servers for the subnet. For example:

["8.8.8.7", "8.8.8.8"]

host_routes — a list of host route dictionaries for the subnet. For example:

[
    {"destination": "0.0.0.0/0", "nexthop": "123.456.78.9"},
    {"destination": "192.168.0.0/24", "nexthop": "192.168.0.1"},
]

ipv6_ra_mode (string) — IPv6 Router Advertisement mode. Valid values are: 'dhcpv6-stateful', 'dhcpv6-stateless', or 'slaac'.
ipv6_address_mode (string) — IPv6 address mode. Valid values are: 'dhcpv6-stateful', 'dhcpv6-stateless', or 'slaac'.
prefixlen (string) — the prefix length to use for subnet allocation from a subnetpool
use_default_subnetpool (bool) — use the default subnetpool for ip_version to obtain a CIDR. Only one of cidr, use_default_subnetpool and subnetpool_name_or_id may be specified at the same time. (Yes, saying it again. It's that serious.)
subnetpool_name_or_id (string) — the unique name or id of the subnetpool to grab a CIDR from. Only one of cidr, use_default_subnetpool and subnetpool_name_or_id may be specified at the same time.
kwargs — key value pairs passed straight to the Neutron API ✨

Returns — the created network Subnet object 🎀

Raises — SDKException (that's openstack.exceptions.SDKException) on operation error

`create_user`

create_user(name, password=None, email=None,
default_project=None, enabled=True, domain_id=None,
description=None)

Create a user. That's it, that's the whole thing. Iconic minimalism 💜

`create_volume`

create_volume(size, wait=True, timeout=None, image=None,
bootable=None, **kwargs)

Create a volume. Big storage energy 🔥

Parameters

size — size, in GB, of the volume you're creating
wait — if true, it waits for the volume to be created
timeout — seconds to wait for volume creation. None is forever 🌈
image — (optional) image name, ID or object to create the volume from
bootable — (optional) make this volume bootable. If it's set, wait also gets set to true.
kwargs — keyword arguments as expected for the cinder client

Returns — the created volume Volume object

Raises — ResourceTimeout (openstack.exceptions.ResourceTimeout) if the wait time is exceeded ⏰

Raises — SDKException (openstack.exceptions.SDKException) on operation error

`create_volume_backup`

create_volume_backup(volume_id, name=None, description=None,
force=False, wait=True, timeout=None, incremental=False,
snapshot_id=None)

Create a volume backup. Because bestie, you need a backup 🫶

Parameters

volume_id — the ID of the volume to back up
name — name of the backup. One gets generated for you if you don't provide one.
description — description of the backup. Same deal, one gets generated if you don't provide one.
force — if set to True the backup gets created even if the volume is attached to an instance; if False, it won't
wait — if true, it waits for the volume backup to be created
timeout — seconds to wait for the volume backup creation. None is forever
incremental — if set to true, the backup will be incremental
snapshot_id — the UUID of the source snapshot to back up

Returns — the created volume Backup object

Raises — ResourceTimeout (openstack.exceptions.ResourceTimeout) if the wait time is exceeded

Raises — SDKException (openstack.exceptions.SDKException) on operation error

`create_volume_snapshot`

create_volume_snapshot(volume_id, force=False, wait=True,
timeout=None, **kwargs)

Create a snapshot 📸

Parameters

volume_id — the ID of the volume to snapshot
force — if set to True the snapshot gets created even if the volume is attached to an instance; if False, it won't
name — name of the snapshot. One gets generated if you don't provide one.
description — description of the snapshot. One gets generated if you don't provide one.
wait — if true, it waits for the volume snapshot to be created
timeout — seconds to wait for the volume snapshot creation. None is forever

Returns — the created volume Snapshot object

Raises — ResourceTimeout (openstack.exceptions.ResourceTimeout) if the wait time is exceeded

Raises — SDKException (openstack.exceptions.SDKException) on operation error

`create_zone`

create_zone(name, zone_type=None, email=None, description=None,
ttl=None, masters=None)

Create a brand new zone 🌸

Parameters

name — name of the zone being created
zone_type — type of the zone (primary/secondary)
email — email of the zone owner (only applies if zone_type is primary)
description — description of the zone
ttl — TTL (Time to live) value in seconds
masters — master nameservers (only applies if zone_type is secondary)

Returns — a dict representing the created zone ✨

Raises — SDKException (openstack.exceptions.SDKException) on operation error

property `current_location`

Returns a utils.Munch explaining the current cloud location 🌍

property `current_project`

Returns a utils.Munch describing the current project

property `current_project_id`

Get the current project ID 🪪

Returns the project_id of the current token scope. None means the token is domain scoped or unscoped.

Raises

keystoneauth1.exceptions.auth.AuthorizationFailure — if a new token fetch fails. 😭
keystoneauth1.exceptions.auth_plugins.MissingAuthPlugin — if a plugin is not available. 💀

property current_user_id — grabs the id of whoever's logged in rn, straight from the token. no cap, it just reads it off the token. 🫶

`delete_accelerator_request(uuid, filters=None)`

Deletes a accelerator_request. bye bestie 👋

Parameters:

uuid — the UUID of the accelerator request you're deleting.
filters — dict of filter conditions to push down.

Returns: True if delete succeeded, False otherwise.

`delete_aggregate(name_or_id)`

Deletes a host aggregate. it's giving cleanup era ✨

Parameters:

name_or_id — Name or ID of the host aggregate to delete.

Returns: True if delete succeeded, False otherwise.

Raises: SDKException <#openstack.exceptions.SDKException> on operation error.

`delete_autocreated_image_objects(container=None, segment_prefix=None)`

Deletes all objects autocreated for image uploads. like, every single one. 🧹

Lowkey you should NOT need this method most of the time — shade is supposed to clean up the objects it uses for object-based image creation all on its own. but if something goes wrong and it turns out there are leaked objects chilling there, this method is the one to call to delete any objects that shade created on the user's behalf in service of image uploads. it's the cleanup crew fr fr. 🎀

Parameters:

container (str) — Name of the container. Defaults to 'images'.
segment_prefix (str) — Prefix for the image segment names to delete. If not given, all image upload segments present are deleted.

Returns: True if deletion was successful, else False.

`delete_cluster_template(name_or_id)`

Deletes a cluster template. poof 💅

Parameters:

name_or_id — Name or unique ID of the cluster template.

Returns: True if the delete succeeded, False if the cluster template was not found.

Raises: SDKException <#openstack.exceptions.SDKException> on operation error.

`delete_coe_cluster(name_or_id)`

Deletes a COE cluster. ✨

Parameters:

name_or_id — Name or unique ID of the cluster.

Returns: True if the delete succeeded, False if the cluster was not found.

Raises: SDKException <#openstack.exceptions.SDKException> on operation error.

`delete_compute_quotas(name_or_id)`

Deletes quota for a project. quota? gone. 🦋

Parameters:

name_or_id — project name or id.

Raises: SDKException <#openstack.exceptions.SDKException> if it's not a valid project or the nova client call failed.

`delete_container(name)`

Deletes an object-store container. 🎀

Parameters:

name (str) — Name of the container to delete.

`delete_device_profile(uuid, filters=None)`

Deletes a device_profile. slay 💜

Parameters:

uuid — the UUID of the device profile to be deleted.
filters — dict of filter conditions to push down.

Returns: True if delete succeeded, False otherwise.

`delete_domain(domain_id=None, name_or_id=None)`

Deletes a Keystone domain. 👑

Parameters:

domain_id — ID of the domain to delete.
name_or_id — Name or unique ID of the domain.

Returns: True if delete succeeded, False otherwise.

Raises: SDKException <#openstack.exceptions.SDKException> if something goes wrong during the OpenStack API call.

`delete_endpoint(id)`

Deletes a Keystone endpoint. icon behavior 🔥

Parameters:

id — ID of the endpoint to delete.

Returns: True if delete succeeded, False otherwise.

Raises: SDKException <#openstack.exceptions.SDKException> if something goes wrong during the OpenStack API call.

`delete_endpoint_group(id)`

Deletes a Keystone endpoint group. the whole squad, deleted. 😭

Parameters:

id — ID of the endpoint group to delete.

Returns: True if delete succeeded, False otherwise.

Raises: SDKException <#openstack.exceptions.SDKException> if something goes wrong during the OpenStack API call.

`delete_firewall_group(name_or_id, filters=None)`

Deletes a firewall group. prints a debug message in case the to-be-deleted resource was not found — so it's not just silently ghosting you, ok? 🙈

Parameters:

name_or_id — firewall group name or id.
filters (dict) — optional filters.

Raises: DuplicateResource on multiple matches.

Returns: True if resource is successfully deleted, False otherwise.

Return type: bool

`delete_firewall_policy(name_or_id, filters=None)`

Deletes a firewall policy. prints a debug message in case the to-be-deleted resource was not found. 🎀

Parameters:

name_or_id — firewall policy name or id.
filters —

A dictionary of meta data to use for further filtering. Elements of this dictionary may, themselves, be dictionaries. Example:

{'last_name': 'Smith', 'other': {'gender': 'Female'}}

OR a string containing a jmespath expression for further filtering. Example:

"[?last_name==`Smith`] | [?other.gender]==`Female`]"

Raises: DuplicateResource on multiple matches.

Returns: True if resource is successfully deleted, False otherwise.

Return type: bool

`delete_firewall_rule(name_or_id, filters=None)`

Deletes a firewall rule.

Prints a debug message in case the to-be-deleted resource was not found. (again, no silent ghosting 💀)

Parameters:

name_or_id — firewall rule name or id.
filters —

A dictionary of meta data to use for further filtering. Elements of this dictionary may, themselves, be dictionaries. Example:

{'last_name': 'Smith', 'other': {'gender': 'Female'}}

OR a string containing a jmespath expression for further filtering. Example:

"[?last_name==`Smith`] | [?other.gender]==`Female`]"

Raises: DuplicateResource on multiple matches.

Returns: True if resource is successfully deleted, False otherwise.

Return type: bool

`delete_flavor(name_or_id)`

Deletes a flavor. bye flavor 💅

Parameters:

name_or_id — ID or name of the flavor to delete.

Returns: True if delete succeeded, False otherwise.

Raises: SDKException <#openstack.exceptions.SDKException> on operation error.

`delete_floating_ip(floating_ip_id, retry=1)`

Deallocates a floating IP from a project. releasing it back into the wild 🌈

Parameters:

floating_ip_id — a floating IP address ID.
retry — number of times to retry. Optional, defaults to 1, which is in addition to the initial delete call. A value of 0 will also cause no checking of results to occur.

Returns: True if the IP address has been deleted, False if the IP address was not found.

Raises: SDKException <#openstack.exceptions.SDKException> on operation error.

`delete_group(name_or_id)`

Deletes a group. 👯

Parameters:

name_or_id — Name or unique ID of the group.

Returns: True if delete succeeded, False otherwise.

Raises: SDKException <#openstack.exceptions.SDKException> if something goes wrong during the OpenStack API call.

`delete_image(name_or_id, wait=False, timeout=3600, delete_objects=True)`

Deletes an existing image. 🖼️

Parameters:

name_or_id — Name of the image to be deleted.
wait — If True, waits for image to be deleted.
timeout — Seconds to wait for image deletion. None is forever. (yes, forever forever 😭)
delete_objects — If True, also deletes uploaded swift objects.

Returns: True if delete succeeded, False otherwise.

Raises: SDKException <#openstack.exceptions.SDKException> if there are problems deleting.

`delete_keypair(name)`

Deletes a keypair. 🔑

Parameters:

name — Name of the keypair to delete.

Returns: True if delete succeeded, False otherwise.

(...and yeah, that previous one raises SDKException on operation error too — forgot to mention it before the page break, my bad bestie 😭)

✂️ `delete_network(name_or_id)`

Delete a network. Poof. Gone. 💨

Parameters

name_or_id — Name or ID of the network being deleted.

Returns

True if delete succeeded, False otherwise.

Raises SDKException on operation error.

🧮 `delete_network_quotas(name_or_id)`

Delete network quotas for a project. Bye-bye limits 🎀

Parameters

name_or_id — project name or id

Returns

dict with the quotas

Raises SDKException if it's not a valid project or the network client call failed

🗃️ `delete_object(container, name, meta=None)`

Delete an object from a container. Like yeeting a file out of a bucket, but make it cloud ☁️

Parameters

container (string) — Name of the container holding the object.
name (string) — Name of the object to delete.
meta (dict) — Metadata for the object in question. (optional, will be fetched if not provided)

Returns

True if delete succeeded, False if the object was not found.

Raises SDKException on operation error.

🔌 `delete_port(name_or_id)`

Delete a port 🚪

Parameters

name_or_id — ID or name of the port to delete.

Returns

True if delete succeeded, False otherwise.

Raises SDKException on operation error.

📁 `delete_project(name_or_id, domain_id=None)`

Delete a project. Iconic behaviour, honestly 👑

Parameters

name_or_id — Name or unique ID of the project.
domain_id — Domain ID to scope the retrieved project.

Returns

True if delete succeeded, False if the project was not found.

Raises SDKException if something goes wrong during the OpenStack API call

🚦 `delete_qos_bandwidth_limit_rule(policy_name_or_id, rule_id)`

Delete a QoS bandwidth limit rule. Speed limits, but make it deletion 💅

Parameters

policy_name_or_id (string) — Name or ID of the QoS policy to which rule is associated.
rule_id (string) — ID of rule to update.

Raises SDKException on operation error.

🏷️ `delete_qos_dscp_marking_rule(policy_name_or_id, rule_id)`

Delete a QoS DSCP marking rule 🎯

Parameters

policy_name_or_id (string) — Name or ID of the QoS policy to which rule is associated.
rule_id (string) — ID of rule to update.

Raises SDKException on operation error.

📉 `delete_qos_minimum_bandwidth_rule(policy_name_or_id, rule_id)`

Delete a QoS minimum bandwidth rule. (Note: this one says delete, not update — the other two said update, we're just reporting what the page says, no cap 🤷‍♀️)

Parameters

policy_name_or_id (string) — Name or ID of the QoS policy to which rule is associated.
rule_id (string) — ID of rule to delete.

Raises SDKException on operation error.

🎀 `delete_qos_policy(name_or_id)`

Delete a QoS policy. Whole policy, gone, slay ✨

Parameters

name_or_id — Name or ID of the policy being deleted.

Returns

True if delete succeeded, False otherwise.

Raises SDKException on operation error.

📝 `delete_recordset(zone, name_or_id)`

Delete a recordset.

Parameters

zone — Name, ID or openstack.dns.v2.zone.Zone instance of the zone managing the recordset.
name_or_id — Name or ID of the recordset being deleted.

Returns

True if delete succeeded, False otherwise.

Raises SDKException on operation error.

🔑 `delete_role(name_or_id, **kwargs)`

Delete a Keystone role. Bye permission-dispenser 🫶

Parameters

name_or_id — Name or unique ID of the role.
domain_id — domain id (v3)

Returns

True if delete succeeded, False otherwise.

Raises SDKException if something goes wrong during the OpenStack API call.

🛰️ `delete_router(name_or_id)`

Delete a logical router.

Heads up bestie, this is the important bit: if a name, instead of a unique UUID, is supplied, it is possible that we could find more than one matching router since names are not required to be unique. An error will be raised in this case. So like... use the ID if you can 😭

Parameters

name_or_id — Name or ID of the router being deleted.

Returns

True if delete succeeded, False otherwise.

Raises SDKException on operation error.

🛡️ `delete_security_group(name_or_id)`

Delete a security group

Parameters

name_or_id (string) — The name or unique ID of the security group.

Returns

True if delete succeeded, False otherwise.

Raises SDKException on operation error.

Raises OpenStackCloudUnavailableFeature if security groups are not supported on this cloud.

🚧 `delete_security_group_rule(rule_id)`

Delete a security group rule

Parameters

rule_id (string) — The unique ID of the security group rule.

Returns

True if delete succeeded, False otherwise.

Raises SDKException on operation error.

Raises OpenStackCloudUnavailableFeature if security groups are not supported on this cloud.

💀 `delete_server(name_or_id, wait=False, timeout=180, delete_ips=False, delete_ip_retry=1)`

Delete a server instance. Whole entire server. Into the void 🔥

Parameters

name_or_id — name or ID of the server to delete
wait (bool) — If true, waits for server to be deleted.
timeout (int) — Seconds to wait for server deletion.
delete_ips (bool) — If true, deletes any floating IPs associated with the instance.
delete_ip_retry (int) — Number of times to retry deleting any floating ips, should the first try be unsuccessful.

Returns

True if delete succeeded, False otherwise if the server does not exist.

Raises SDKException on operation error.

👯 `delete_server_group(name_or_id)`

Delete a server group.

Parameters

name_or_id — Name or ID of the server group to delete

Returns

True if delete succeeded, False otherwise

Raises SDKException on operation error.

🏷️ `delete_server_metadata(name_or_id, metadata_keys)`

Delete metadata from a server instance.

Parameters

name_or_id (str) — The name or ID of the server instance to update.
metadata_keys — A list with the keys to be deleted from the server instance.

Returns

None

Raises SDKException on operation error.

🧾 `delete_service(name_or_id)`

Delete a Keystone service.

Parameters

name_or_id — Name or unique ID of the service.

Returns

True if delete succeeded, False otherwise.

Raises SDKException if something goes wrong during the OpenStack API call

🥞 `delete_stack(name_or_id, wait=False)`

Delete a stack

Parameters

name_or_id — Stack name or ID.
wait — Whether to wait for the delete to finish

Returns

True if delete succeeded, False if the stack was not found.

Raises SDKException if something goes wrong during the OpenStack API call

🌐 `delete_subnet(name_or_id)`

Delete a subnet.

Okay same warning as the router one, because apparently we gotta say it twice: if a name, instead of a unique UUID, is supplied, it is possible that we could find more than one matching subnet since names are not required to be unique. An error will be raised in this case. Names are lowkey not it, use IDs 💅

Parameters

name_or_id — Name or ID of the subnet being deleted.

Returns: True if delete succeeded, False otherwise.

Raises: SDKException (#openstack.exceptions.SDKException) on operation error.

`delete_unattached_floating_ips(retry=1)`

Okay so this one safely deletes unattached floating IPs. If the cloud can safely purge any unattached floating IPs without race conditions, it does so. 💅

Safely here means a specific thing. It means that you are not running this while another process that might do a two step create/attach is running. You can safely run this method while another process is creating servers and attaching floating IPs to them if either that process is using add_auto_ip from shade, or is creating the floating IPs by passing in a server to the create_floating_ip call. iykyk ✨

Parameters

retry — number of times to retry. Optional, defaults to 1, which is in addition to the initial delete call. A value of 0 will also cause no checking of results to occur.

Returns: Number of Floating IPs deleted, False if none.

Raises: SDKException (#openstack.exceptions.SDKException) on operation error.

`delete_volume(name_or_id, wait=True, timeout=None, force=False)`

Delete a volume. Main character deletion energy, but make it safe. 🦋

Parameters

name_or_id — Name or unique ID of the volume.
wait — If true, waits for volume to be deleted.
timeout — Seconds to wait for volume deletion. None is forever.
force — Force delete volume even if the volume is in deleting or error_deleting state.

Returns: True if deletion was successful, else False.

Raises: ResourceTimeout (#openstack.exceptions.ResourceTimeout) if wait time exceeded.

Raises: SDKException (#openstack.exceptions.SDKException) on operation error.

`delete_volume_backup(name_or_id=None, force=False, wait=False, timeout=None)`

Delete a volume backup. Bestie, check the force/wait combo before you yeet it. 🎀

Parameters

name_or_id — Name or unique ID of the volume backup.
force — Allow delete in state other than error or available.
wait — If true, waits for volume backup to be deleted.
timeout — Seconds to wait for volume backup deletion. None is forever.

Returns: True if deletion was successful, else False.

Raises: ResourceTimeout (#openstack.exceptions.ResourceTimeout) if wait time exceeded.

Raises: SDKException (#openstack.exceptions.SDKException) on operation error.

`delete_volume_quotas(name_or_id)`

Delete volume quotas for a project. Quota cleanup era. 💜

Parameters

name_or_id — project name or id.

Returns: The deleted volume QuotaSet object.

Raises: SDKException (#openstack.exceptions.SDKException) if it's not a valid project or the call failed.

`delete_volume_snapshot(name_or_id=None, wait=False, timeout=None)`

Delete a volume snapshot. Snap it away, but mind the wait. 🍓

Parameters

name_or_id — Name or unique ID of the volume snapshot.
wait — If true, waits for volume snapshot to be deleted.
timeout — Seconds to wait for volume snapshot deletion. None is forever.

Returns: True if deletion was successful, else False.

Raises: ResourceTimeout (#openstack.exceptions.ResourceTimeout) if wait time exceeded.

Raises: SDKException (#openstack.exceptions.SDKException) on operation error.

`delete_zone(name_or_id)`

Delete a zone. Zone be gone, respectfully. 🦋

Parameters

name_or_id — Name or ID of the zone being deleted.

Returns: True if delete succeeded, False otherwise.

Raises: SDKException (#openstack.exceptions.SDKException) on operation error.

`detach_ip_from_server(server_id, floating_ip_id)`

Detach a floating IP from a server. Unattach that little IP, bestie. ✨

Parameters

server_id — ID of a server.
floating_ip_id — Id of the floating IP to detach.

Returns: True if the IP has been detached, or False if the IP wasn't attached to any server.

Raises: SDKException (#openstack.exceptions.SDKException) on operation error.

`detach_port_from_machine(name_or_id, port_name_or_id)`

Detach a virtual port from the bare metal machine. Port detachment, but make it metal. 💅

Parameters

name_or_id (string) — A machine name or UUID.
port_name_or_id (string) — A port name or UUID. Note that this is a Network service port, not a bare metal NIC.

Returns: Nothing.

`detach_volume(server, volume, wait=True, timeout=None)`

Detach a volume from a server. Volume breakup, but clean. 💔✨

Parameters

server — The server dict to detach from.
volume — The volume dict to detach.
wait — If true, waits for volume to be detached.
timeout — Seconds to wait for volume detachment. None is forever.

Returns: None

Raises: ResourceTimeout (#openstack.exceptions.ResourceTimeout) if wait time exceeded.

Raises: SDKException (#openstack.exceptions.SDKException) on operation error.

`download_image(name_or_id, output_path=None, output_file=None, chunk_size=1048576, stream=False)`

Download an image by name or ID. Literally saving the whole image to your whole vibe. 🎀

Parameters

name_or_id (str) — Name or ID of the image.
output_path — the output path to write the image to. Either this or output_file must be specified.
output_file — a file object (or file-like object) to write the image data to. Only write() will be called on this object. Either this or output_path must be specified.
chunk_size (int) — size in bytes to read from the wire and buffer at one time. Defaults to 1024 * 1024 = 1 MiB.
Param bool stream: — whether to stream the output in chunk_size.

Returns: When output_path and output_file are not given - the bytes comprising the given Image when stream is False, otherwise a requests.Response instance. When output_path or output_file are given - an image Image instance (#openstack.image.v2.image.Image).

Raises: SDKException (#openstack.exceptions.SDKException) in the event download_image is called without exactly one of either output_path or output_file.

Raises: BadRequestException (#openstack.exceptions.BadRequestException) if no images are found matching the name or ID provided.

`export_volume_backup(backup_id)`

Export a volume backup. Backup export, no cap. 🦋

Parameters

backup_id — the ID of the backup.

Returns: The backup export record fields. This is a dict when using the (deprecated) v2 API and a requests.Response when using the v3 API.

Raises: ResourceTimeout (#openstack.exceptions.ResourceTimeout) if wait time exceeded.

Raises: SDKException (#openstack.exceptions.SDKException) on operation error.

`get_aggregate(name_or_id, filters=None)`

Get an aggregate by name or ID. Aggregate fetch, lowkey iconic. ⭐

Parameters

name_or_id — Name or ID of the aggregate.
filters (dict) — DEPRECATED A dictionary of meta data to use for further filtering. Elements of this dictionary may, themselves, be dictionaries. Example:

{
    'availability_zone': 'nova',
    'metadata': {'cpu_allocation_ratio': '1.0'},
}

Returns: An aggregate dict or None if no matching aggregate is found.

`get_cluster_template(name_or_id, filters=None, detail=False)`

Get a cluster template by name or ID. Cluster template fetch, bestie edition. 👑

Parameters

name_or_id — Name or ID of the cluster template.
filters — A dictionary of meta data to use for further filtering. Elements of this dictionary may, themselves, be dictionaries. Example:

{'last_name': 'Smith', 'other': {'gender': 'Female'}}

OR A string containing a jmespath expression for further filtering. Example::

"[?last_name==`Smith`] | [?other.gender]==`Female`]"

Returns: A cluster template dict or None if no matching cluster template is found.

`get_coe_cluster(name_or_id, filters=None)`

Get a COE cluster by name or ID. 🫶

Parameters:

name_or_id — name or ID of the cluster, bestie.
filters — A dictionary of meta data to use for further filtering. Elements of this dictionary may, themselves, be dictionaries, iykyk. Example:

{'last_name': 'Smith', 'other': {'gender': 'Female'}}

OR a string containing a jmespath expression for further filtering. Example:

"[?last_name==`Smith`] |
[?other.gender]==`Female`]"

Returns: a container infrastructure management Cluster object if found, else None.

`get_coe_cluster_certificate(cluster_id)`

Get details about the CA certificate for a cluster by name or ID 🔐 (yes, "by name or ID" in the summary but the arg is the ID, that's just how it is, don't @ me).

Parameters:

cluster_id — ID of the cluster.

Returns: details about the CA certificate for the given cluster.

`get_compute_limits(name_or_id=None)`

Get absolute compute limits for a project.

Parameters:

name_or_id — (optional) project name or ID to get limits for, if it's different from the current project.

Returns: a compute AbsoluteLimits object.

Raises: SDKException <#openstack.exceptions.SDKException> if it's not a valid project 😭

`get_compute_quotas(name_or_id)`

Get quota for a project.

Parameters:

name_or_id — project name or id.

Returns: a compute QuotaSet object if found, else None.

Raises: SDKException <#openstack.exceptions.SDKException> if it's not a valid project.

`get_compute_usage(name_or_id, start=None, end=None)`

Get usage for a specific project ⏰

Parameters:

name_or_id — project name or id.
start — datetime.datetime or string. Start date in UTC. Defaults to 2010-07-06T12:00:00Z (the date the OpenStack project was started, iconic origin story ngl).
end — datetime.datetime or string. End date in UTC. Defaults to now.

Returns: a Usage <#openstack.compute.v2.usage.Usage> object.

Raises: SDKException <#openstack.exceptions.SDKException> if it's not a valid project.

`get_container(name, skip_cache=False)`

Get metadata about a container 🍓

Parameters:

name (str) — name of the container to get metadata for.
skip_cache (bool) — ignored. Present for backwards compatibility. (It literally does nothing, bestie, it's just there so old code doesn't break 💀)

Returns: an object store Container object if found, else None.

`get_container_access(name)`

Get the control list from a container 🔑

Parameters:

name (str) — name of the container.

Returns: the control list for the container.

Raises: SDKException <#openstack.exceptions.SDKException> if the container was not found or container access could not be determined.

`get_default_network()`

Return the network that is configured to be the default interface. The main character network, basically 👑

Returns: a network Network object if one is found.

`get_domain(domain_id=None, name_or_id=None, filters=None)`

Get exactly one Keystone domain.

Parameters:

domain_id — ID of the domain.
name_or_id — name or unique ID of the domain.
filters — DEPRECATED 🚨 A dictionary of meta data to use for further filtering. Elements of this dictionary may, themselves, be dictionaries. Example:

{'last_name': 'Smith', 'other': {'gender': 'Female'}}

A string containing a jmespath expression for further filtering. Example:

"[?last_name==`Smith`] | [?other.gender]==`Female`]"

Returns: an identity Domain object.

Raises: SDKException <#openstack.exceptions.SDKException> if something goes wrong during the OpenStack API call.

`get_endpoint(id, filters=None)`

Get exactly one Keystone endpoint.

Parameters:

id — ID of endpoint.

Returns: an identity Endpoint object.

`get_endpoint_group(id)`

Get exactly one Keystone endpoint group.

Parameters:

id — ID of endpoint group.

Returns: an identity EndpointGroup object.

`get_external_ipv4_floating_networks()`

Return the networks that are configured to route northbound 🌈

Returns: a list of network Network objects if any are found.

`get_external_ipv4_networks()`

Return the networks that are configured to route northbound.

Returns: a list of network Network objects if any are found.

`get_external_ipv6_networks()`

Return the networks that are configured to route northbound.

Returns: a list of network Network objects if any are found.

`get_external_networks()`

Return the networks that are configured to route northbound.

Heads up bestie ⚠️ — this one should be avoided in favor of the specific ipv4/ipv6 method, but is here for backwards compatibility. It's giving legacy energy.

Returns: a list of network Network objects if any are found.

`get_firewall_group(name_or_id, filters=None)`

Retrieves firewall group 🔥

Parameters:

name_or_id — firewall group name or id.
filters (dict) — optional filters.

Raises: DuplicateResource on multiple matches.

Returns: a network FirewallGroup object if found, else None.

`get_firewall_policy(name_or_id, filters=None)`

Retrieves a single firewall policy.

Parameters:

name_or_id — firewall policy name or id.
filters — A dictionary of meta data to use for further filtering. Elements of this dictionary may, themselves, be dictionaries. Example:

{'last_name': 'Smith', 'other': {'gender': 'Female'}}

OR a string containing a jmespath expression for further filtering. Example:

"[?last_name==`Smith`] |
[?other.gender]==`Female`]"

Raises: DuplicateResource on multiple matches.

Returns: a network FirewallPolicy object if found, else None.

`get_firewall_rule(name_or_id, filters=None)`

Retrieves a single firewall rule.

Parameters:

name_or_id — firewall rule name or id.
filters — A dictionary of meta data to use for further filtering. Elements of this dictionary may, themselves, be dictionaries. Example:

{'last_name': 'Smith', 'other': {'gender': 'Female'}}

OR a string containing a jmespath expression for further filtering. Example:

"[?last_name==`Smith`] |
[?other.gender]==`Female`]"

Raises: DuplicateResource on multiple matches.

Returns: a network FirewallRule object if found, else None.

`get_flavor(name_or_id, filters=None, get_extra=True)`

Get a flavor by name or ID, slay 🍓

Parameters:

name_or_id — name or ID of the flavor.
filters — DEPRECATED 🚨 A dictionary of meta data to use for further filtering. Elements of this dictionary may, themselves, be dictionaries. Example:

{'last_name': 'Smith', 'other': {'gender': 'Female'}}

OR a string containing a jmespath expression for further filtering. Example:

"[?last_name==`Smith`] |
[?other.gender]==`Female`]"

get_extra — whether or not the list_flavors call should get the extra flavor specs.

Returns: a compute Flavor object if found, else None.

`get_flavor_by_id(id, get_extra=False)`

Get a flavor by ID.

Parameters:

id — ID of the flavor.
get_extra — whether or not the list_flavors call should get the extra flavor specs. (Note it defaults to False here, not True — different vibe from its sibling above 👀)

Returns: a compute Flavor object if found, else None.

`get_flavor_by_ram(ram, include=None, get_extra=True)`

Get a flavor based on amount of RAM available 🧠

Finds the flavor with the least amount of RAM that is at least as much as the specified amount. If include is given, further filter based on matching flavor name.

Parameters:

ram (int) — minimum amount of RAM.
include (string) — If given, will return a flavor whose name contains this string as a substring. 🍓
get_extra — Whether to fetch extra specs. ✨

Returns: A compute Flavor object. 👑

Raises SDKException <#openstack.exceptions.SDKException> if no matching flavour could be found. 😭

`get_flavor_name(flavor_id)`

Get the name of a flavor, bestie. 💅

Parameters:

flavor_id — ID of the flavor.

Returns: The name of the flavor if a match if found, else None. 🎀

`get_floating_ip(id, filters=None)`

Get a floating IP by ID. 🌈

Parameters:

id — ID of the floating IP.
filters — A dictionary of meta data to use for further filtering. Elements of this dictionary may, themselves, be dictionaries. Example:

{'last_name': 'Smith', 'other': {'gender': 'Female'}}

OR A string containing a jmespath expression for further filtering. Example:

"[?last_name==`Smith`] | [?other.gender]==`Female`]"

Returns: A floating IP openstack.network.v2.floating_ip.FloatingIP or None if no matching floating IP is found. 🦋

`get_floating_ip_by_id(id)`

Get a floating ip by ID.

Parameters:

id — ID of the floating ip.

Returns: A floating ip :class:`~openstack.network.v2.floating_ip.FloatingIP. 💜

`get_group(name_or_id, filters=None, domain_id=None)`

Get exactly one Keystone group. 👑

Parameters:

name_or_id — Name or unique ID of the group(s).
domain_id — Domain ID to scope the retrieved group.

Returns: An identity Group object.

Raises SDKException <#openstack.exceptions.SDKException> if something goes wrong during the OpenStack API call. 😭

`get_image(name_or_id, filters=None)`

Get an image by name or ID. 🖼️

Parameters:

name_or_id — Name or ID of the image.
filters — A dictionary of meta data to use for further filtering. Elements of this dictionary may, themselves, be dictionaries. Example:

{'last_name': 'Smith', 'other': {'gender': 'Female'}}

OR A string containing a jmespath expression for further filtering. Example:

"[?last_name==`Smith`] | [?other.gender]==`Female`]"

Returns: An image openstack.image.v2.image.Image <#openstack.image.v2.image.Image> object. 🌸

`get_image_by_id(id)`

Get a image by ID.

Parameters:

id — ID of the image.

Returns: An image openstack.image.v2.image.Image <#openstack.image.v2.image.Image> object. ✨

`get_internal_ipv4_networks()`

Return the networks that are configured to not route northbound. 🛰️

Returns: A list of network Network objects if any are found.

`get_internal_ipv6_networks()`

Return the networks that are configured to not route northbound. 🛰️

Returns: A list of network Network objects if any are found.

`get_internal_networks()`

Return the networks that are configured to not route northbound. 🛰️

⚠️ This should be avoided in favor of the specific ipv4/ipv6 method, but is here for backwards compatibility.

Returns: A list of network Network objects if any are found.

`get_keypair(name_or_id, filters=None, *, user_id=None)`

Get a keypair by name or ID. 🔑

Parameters:

name_or_id — Name or ID of the keypair.
filters — 🚨 DEPRECATED A dictionary of meta data to use for further filtering. Elements of this dictionary may, themselves, be dictionaries. Example:

{'last_name': 'Smith', 'other': {'gender': 'Female'}}

OR A string containing a jmespath expression for further filtering. Example:

"[?last_name==`Smith`] | [?other.gender]==`Female`]"

user_id — User to retrieve keypair from.

Returns: A compute Keypair object if found, else None. 💖

`get_machine(name_or_id)`

Get Machine by name or uuid. 🤖

Search the baremetal host out by utilizing the supplied id value which can consist of a name or UUID.

Parameters:

name_or_id — A node name or UUID that will be looked up.

Return type: Node <#openstack.baremetal.v1.node.Node>.

Returns: The node found or None if no nodes are found. 🦋

`get_machine_by_mac(mac)`

Get machine by port MAC address. 🔌

Parameters:

mac — Port MAC address to query in order to return a node.

Return type: Node <#openstack.baremetal.v1.node.Node>.

Returns: The node found or None if no nodes are found. 💫

`get_nat_destination()`

Return the network that is configured to be the NAT destination. 🌐

Returns: A network Network object if one is found.

`get_nat_source()`

Return the network that is configured to be the NAT destination. 🌐

Returns: A network Network object if one is found.

`get_network(name_or_id, filters=None)`

Get a network by name or ID. 🕸️

Parameters:

name_or_id — Name or ID of the network.
filters — A dictionary of meta data to use for further filtering. Elements of this dictionary may, themselves, be dictionaries. Example:

{'last_name': 'Smith', 'other': {'gender': 'Female'}}

OR A string containing a jmespath expression for further filtering. Example:

"[?last_name==`Smith`] | [?other.gender]==`Female`]"

Returns: A network Network object if found, else None. ✨

`get_network_by_id(id)`

Get a network by ID.

Parameters:

id — ID of the network.

Returns: A network Network object if found, else None. 💜

`get_network_extensions()`

Get Cloud provided network extensions. ☁️

Returns: A set of Neutron extension aliases. 🎀

`get_network_quotas(name_or_id, details=False)`

Get network quotas for a project. 📊

Parameters:

name_or_id — project name or id
details — if set to True it will return details about usage of quotas by given project

Returns: A network Quota object if found, else None.

Raises SDKException <#openstack.exceptions.SDKException> if it's not a valid project. 😭

`get_nic_by_mac(mac)`

Get bare metal NIC by its hardware address (usually MAC). 🔎

`get_object(container, obj, query_string=None, resp_chunk_size=1024, outfile=None, stream=False)`

Get the headers and body of an object. 📦

Parameters:

container (string) — Name of the container.
obj (string) — Name of the object.
query_string (string) — Query args for uri. (delimiter, prefix, etc.)
resp_chunk_size (int) — Chunk size of data to read. Only used if the results are being written to a file or stream is True. (optional, defaults to 1k)
outfile — Write the object to a file instead of returning the contents. If this option is given, body in the return tuple will be None. outfile can either be a file path given as a string, or a File like object.

Returns: Tuple (headers, body) of the object, or None if the object is not found (404). 🫶

Raises SDKException <#openstack.exceptions.SDKException> on operation error. 💀

`get_object_capabilities()`

Get infomation about the object-storage service. 🗂️

The object-storage service publishes a set of capabilities that include metadata about maximum values and thresholds.

Returns: An object store Info object. 👑

`get_object_metadata(container, name)`

Get object metadata. 🏷️

Parameters:

container
name

Returns: The object metadata. ✨

`get_object_raw(container, obj, query_string=None, stream=False)`

Get a raw response object for an object. 🧚

Parameters:

container (string) — Name of the container.
obj (string) — the name of the object, bestie.
query_string (string) — the query args for the uri (delimiter, prefix, etc., all that good stuff).
stream (bool) — whether we're streaming the response or not.

Returns — a requests.Response 💌

Raises SDKException <#openstack.exceptions.SDKException> on operation error. 😭

`get_object_segment_size(segment_size)`

okay so this one gets you a segment size that will actually work given the capabilities. so thoughtful of it 🫶

Parameters — segment_size

Returns — a segment size. literally that's it, slay.

`get_port(name_or_id, filters=None)`

Get a port by name or ID.

Parameters

name_or_id — the name or ID of the port.
filters — a dictionary of meta data to use for further filtering. Elements of this dictionary may, themselves, be dictionaries. Example:

{'last_name': 'Smith', 'other': {'gender': 'Female'}}

OR a string containing a jmespath expression for further filtering. Example:

"[?last_name==`Smith`] | [?other.gender]==`Female`]"

Returns — a network Port object if found, else None. 💅

`get_port_by_id(id)`

Get a port by ID.

Parameters — id — the ID of the port.

Returns — a network Port object if found, else None.

`get_project(name_or_id, filters=None, domain_id=None)`

Get exactly one project. exactly one. no crumbs, no extras 👑

Parameters

name_or_id — name or unique ID of the project.
filters — DEPRECATED ⚠️ a dictionary of meta data to use for further filtering. Elements of this dictionary may, themselves, be dictionaries. Example:

{'last_name': 'Smith', 'other': {'gender': 'Female'}}

OR a string containing a jmespath expression for further filtering. Example:

"[?last_name==`Smith`] | [?other.gender]==`Female`]"

domain_id — domain ID to scope the retrieved project.

Returns — an identity Project object.

Raises SDKException <#openstack.exceptions.SDKException> if something goes wrong during the OpenStack API call. 😭

`get_qos_bandwidth_limit_rule(policy_name_or_id, rule_id)`

Get a QoS bandwidth limit rule by name or ID.

Parameters

policy_name_or_id (string) — name or ID of the QoS policy to which the rule should be associated.
rule_id — ID of the rule.

Returns — a network QoSBandwidthLimitRule object if found, else None.

`get_qos_dscp_marking_rule(policy_name_or_id, rule_id)`

Get a QoS DSCP marking rule by name or ID.

Parameters

policy_name_or_id (string) — name or ID of the QoS policy to which the rule should be associated.
rule_id — ID of the rule.

Returns — a network QoSDSCPMarkingRule object if found, else None.

`get_qos_minimum_bandwidth_rule(policy_name_or_id, rule_id)`

Get a QoS minimum bandwidth rule by name or ID.

Parameters

policy_name_or_id (string) — name or ID of the QoS policy to which the rule should be associated.
rule_id — ID of the rule.

Returns — a network QoSMinimumBandwidthRule object if found, else None.

`get_qos_policy(name_or_id, filters=None)`

Get a QoS policy by name or ID.

Parameters

name_or_id — name or ID of the policy.
filters — a dictionary of meta data to use for further filtering. Elements of this dictionary may, themselves, be dictionaries. Example:

{'last_name': 'Smith', 'other': {'gender': 'Female'}}

OR a string containing a jmespath expression for further filtering. Example:

"[?last_name==`Smith`] | [?other.gender]==`Female`]"

Returns — a network QoSPolicy object if found, else None. ✨

`get_qos_rule_type_details(rule_type, filters=None)`

Get QoS rule type details by rule type name.

Parameters

rule_type — name of the QoS rule type.
filters — a dictionary of meta data to use for further filtering. Elements of this dictionary may, themselves, be dictionaries. Example:

{'last_name': 'Smith', 'other': {'gender': 'Female'}}

OR a string containing a jmespath expression for further filtering. Example:

"[?last_name==`Smith`] | [?other.gender]==`Female`]"

Returns — a network QoSRuleType object if found, else None.

`get_recordset(zone, name_or_id)`

Get a recordset by name or ID.

Parameters

zone — name, ID or openstack.dns.v2.zone.Zone <# openstack.dns.v2.zone.Zone> instance of the zone managing the recordset.
name_or_id — name or ID of the recordset.

Returns — a recordset dict or None if no matching recordset is found. 🦋

`get_role(name_or_id, filters=None, domain_id=None)`

Get a Keystone role.

Parameters

name_or_id — name or unique ID of the role.
domain_id — domain ID to scope the retrieved role.

Returns — an identity Role object if found, else None.

Raises SDKException <#openstack.exceptions.SDKException> if something goes wrong during the OpenStack API call. 😭

`get_router(name_or_id, filters=None)`

Get a router by name or ID.

Parameters

name_or_id — name or ID of the router.
filters — a dictionary of meta data to use for further filtering. Elements of this dictionary may, themselves, be dictionaries. Example:

{'last_name': 'Smith', 'other': {'gender': 'Female'}}

OR a string containing a jmespath expression for further filtering. Example:

"[?last_name==`Smith`] | [?other.gender]==`Female`]"

Returns — a network Router object if found, else None. 💜

`get_security_group(name_or_id, filters=None)`

Get a security group by name or ID.

Parameters

name_or_id — name or ID of the security group.
filters — a dictionary of meta data to use for further filtering. Elements of this dictionary may, themselves, be dictionaries. Example:

{'last_name': 'Smith', 'other': {'gender': 'Female'}}

OR a string containing a jmespath expression for further filtering. Example:

"[?last_name==`Smith`] | [?other.gender]==`Female`]"

Returns — a security group openstack.network.v2.security_group.SecurityGroup or None if no matching security group is found. 🎀

`get_security_group_by_id(id)`

Get a security group by ID.

Parameters — id — the ID of the security group.

Returns — a security group openstack.network.v2.security_group.SecurityGroup.

`get_server(name_or_id=None, filters=None, detailed=False, bare=False, all_projects=False)`

Get a server by name or ID. the main character of compute calls ngl 💅

Parameters

name_or_id — name or ID of the server.
filters — DEPRECATED ⚠️ a dictionary of meta data to use for further filtering. Elements of this dictionary may, themselves, be dictionaries. Example:

{'last_name': 'Smith', 'other': {'gender': 'Female'}}

OR a string containing a jmespath expression for further filtering. Example:

"[?last_name==`Smith`] | [?other.gender]==`Female`]"

detailed — whether or not to add detailed additional information. Defaults to False.
bare — whether to skip adding any additional information to the server record. Defaults to False, meaning the addresses dict will be populated as needed from neutron. Setting to True implies detailed = False. 🔥
all_projects — whether to get the server from all projects or just the current auth scoped project.

Returns — a compute Server object if found, else None.

`get_server_by_id(id)`

Get a server by ID.

Parameters

id — ID of the server.

Returns

A compute Server object if found, else None.

🖥️ `get_server_console(server, length=None)`

Pulls the console log for a server — yes, the actual scrolling wall of text, like the server's diary. 📓✨

Parameters

server — the server you wanna fetch the console log for. Can be either a server dict or the Name or ID of the server.
length (int) — the number of lines you want from the end of the log. (optional, defaults to all — so if you skip it you get the whole thing, no cap)

Returns

A string containing the text of the console log, or an empty string if the cloud does not support console logs.

Raises — SDKException (openstack.exceptions.SDKException) if an invalid server argument is given, or if something else unforeseen happens. 😭

🫂 `get_server_group(name_or_id=None, filters=None)`

Grabs a server group by name or ID. Affinity girlies rise 💅

Parameters

name_or_id — Name or ID of the server group.
filters — DEPRECATED A dictionary of meta data to use for further filtering. Elements of this dictionary may, themselves, be dictionaries. Example:

{
    'policy': 'affinity',
}

OR a string containing a jmespath expression for further filtering. Example::

"[?last_name==`Smith`] | [?other.gender]==`Female`]"

Returns

A compute ServerGroup object if found, else None.

🆔 `get_server_id(name_or_id)`

Finds the ID of a server. ✨

Parameters

name_or_id

Returns

The name of the server if found, else None. (yeah bestie, it says name — that's literally what the manpage says, I'm not fixing it 💀)

🏷️ `get_server_meta(server)`

Gets the metadata for a server.

Deprecated since version — use cloud.compute.fetch_server_metadata(server) instead. She's retired, respect her legacy though 🎀

Parameters

server

Returns

The metadata for the server if found, else None.

🔒 `get_server_private_ip(server)`

Gets the private IP of a server — the inside-voice address, iykyk.

Parameters

server

Returns

The private IP of the server if set, else None.

🌍 `get_server_public_ip(server)`

Gets the public IP of a server — the one that's out here living its main character life on the internet.

Parameters

server

Returns

The public IP of the server if set, else None.

🎫 `get_service(name_or_id, filters=None)`

Gets exactly one Keystone service. Not two. Not zero. One. 👑

Parameters

name_or_id — Name or unique ID of the service.

Returns

an identity Service object

Raises — SDKException (openstack.exceptions.SDKException) if something goes wrong during the OpenStack API call, or if multiple matches are found. 😤

🥞 `get_stack(name_or_id, filters=None, resolve_outputs=True)`

Gets exactly one stack. Heat stack bestie, not a pancake stack, but honestly same energy. 🥞🔥

Parameters

name_or_id — Name or ID of the desired stack.
filters — a dict containing additional filters to use. e.g. {'stack_status': 'CREATE_COMPLETE'}
resolve_outputs — If True, then outputs for this stack will be resolved.

Returns

a openstack.orchestration.v1.stack.Stack containing the stack description

Raises — SDKException (openstack.exceptions.SDKException) if something goes wrong during the OpenStack API call, or if multiple matches are found.

🌐 `get_subnet(name_or_id, filters=None)`

Gets a subnet by name or ID.

Parameters

name_or_id — Name or ID of the subnet.
filters — A dictionary of meta data to use for further filtering. Elements of this dictionary may, themselves, be dictionaries. Example:

{'last_name': 'Smith', 'other': {'gender': 'Female'}}

Returns

A network Subnet object if found, else None.

🔎 `get_subnet_by_id(id)`

Gets a subnet by ID — no name games, straight to the ID.

Parameters

id — ID of the subnet.

Returns

A network Subnet object if found, else None.

🧺 `get_subnetpool(name_or_id)`

Gets a subnetpool by name or ID. The subnet pool, bestie — the whole collection, not one little subnet. 🫶

Parameters

name_or_id — Name or ID of the subnetpool.

Returns

A network Subnetpool object if found, else None.

👤 `get_user(name_or_id, filters=None, domain_id=None)`

Gets exactly one user. One. Singular. 🌟

Parameters

name_or_id — Name or unique ID of the user.
filters — DEPRECATED A dictionary of meta data to use for further filtering. Elements of this dictionary may, themselves, be dictionaries. Example:

{'last_name': 'Smith', 'other': {'gender': 'Female'}}

A string containing a jmespath expression for further filtering. Example:

"[?last_name==`Smith`] | [?other.gender]==`Female`]"

domain_id — Domain ID to scope the retrieved user.

Returns

an identity User object

Raises — SDKException (openstack.exceptions.SDKException) if something goes wrong during the OpenStack API call.

🪪 `get_user_by_id(user_id, normalize=None)`

Gets a user by ID. Very demure, very ID-based. 🎀

Parameters

user_id (string) — user ID

Returns

an identity User object

💾 `get_volume(name_or_id, filters=None)`

Gets a volume by name or ID.

Parameters

name_or_id — Name or unique ID of the volume.
filters — DEPRECATED A dictionary of meta data to use for further filtering. Elements of this dictionary may, themselves, be dictionaries. Example:

{'last_name': 'Smith', 'other': {'gender': 'Female'}}

A string containing a jmespath expression for further filtering. Example:

"[?last_name==`Smith`] | [?other.gender]==`Female`]"

Returns

A volume Volume object if found, else None.

🔌 `get_volume_attach_device(volume, server_id)`

Returns the device name a volume is attached to, for a server. Handy lil trick: this can also be used to verify whether a volume is attached to a particular server at all. Vibe check for attachments 💅

Parameters

volume — The volume to fetch the device name from.
server_id — ID of server to check.

Returns

Device name if attached, None if volume is not attached.

🗄️ `get_volume_backup(name_or_id, filters=None)`

Gets a volume backup by name or ID. Your data's safety net, iconic behaviour honestly. 🦋

Parameters

name_or_id — Name or unique ID of the volume backup.
filters — DEPRECATED A dictionary of meta data to use for further filtering. Elements of this dictionary may, themselves, be dictionaries. Example:

{'last_name': 'Smith', 'other': {'gender': 'Female'}}

A string containing a jmespath expression for further filtering. Example:

"[?last_name==`Smith`] | [?other.gender]==`Female`]"

Returns

A volume Backup object if found, else None.

🔍 `get_volume_by_id(id)`

Gets a volume by ID.

Parameters

id — ID of the volume.

Returns

A volume Volume object if found, else None.

🏷️ `get_volume_id(name_or_id)`

Gets the ID of a volume.

Parameters

name_or_id — Name or unique ID of the volume.

Returns

The ID of the volume if found, else None.

📊 `get_volume_limits(name_or_id=None)`

Gets volume limits for the current project — the receipts on how much room you've got. 🔥

Parameters

name_or_id — (optional) Project name or ID to get limits for, if different from the current project

Returns

The volume Limits object if found, else None.

📏 `get_volume_quotas(name_or_id)`

Gets volume quotas for a project.

Parameters

name_or_id — project name or id

Returns

A volume QuotaSet object with the quotas

Raises — SDKException (openstack.exceptions.SDKException) if it's not a valid project. 🚫

📸 `get_volume_snapshot(name_or_id, filters=None)`

Gets a volume by name or ID. (yep — the manpage literally says "volume" here even though this is the snapshot one; I'm just the messenger bestie 💀)

Parameters

name_or_id — Name or unique ID of the volume snapshot.
filters — (and this is where our part cuts off — catch you in the next bit 🫶💖)
filters — DEPRECATED 💀 A dictionary of meta data to use for further filtering. Elements of this dictionary may, themselves, be dictionaries. Example:

{'last_name': 'Smith', 'other': {'gender': 'Female'}}

OR a string containing a jmespath expression for further filtering. Example:

"[?last_name==`Smith`] | [?other.gender]==`Female`]"

Returns: A volume Snapshot object if found, else None.

🫶 `get_volume_snapshot_by_id(snapshot_id)`

Takes a snapshot_id and gets a dict of the snapshot that matches that ID.

Note: this is more efficient than get_volume_snapshot. ⚡

param: snapshot_id: ID of the volume snapshot. :returns: A volume Snapshot object if found, else None.

🦋 `get_volume_type(name_or_id, filters=None)`

Get a volume type by name or ID.

Parameters:

name_or_id — Name or unique ID of the volume type.
filters — DEPRECATED A dictionary of meta data to use for further filtering. Elements of this dictionary may, themselves, be dictionaries. Example:

{'last_name': 'Smith', 'other': {'gender': 'Female'}}

OR a string containing a jmespath expression for further filtering. Example:

"[?last_name==`Smith`] | [?other.gender]==`Female`]"

Returns: A volume Type object if found, else None.

🎀 `get_volume_type_access(name_or_id)`

Return a list of volume_type_access.

Parameters:

name_or_id — Name or unique ID of the volume type.

Returns: A volume Type object if found, else None.

Raises: SDKException <#openstack.exceptions.SDKException> on operation error. 😭

🌸 `get_volumes(server, cache=None)`

Get volumes for a server.

Parameters:

server — The server to fetch volumes for.
cache — DEPRECATED This parameter no longer does anything. 💀

Returns: A list of volume Volume objects.

✨ `get_zone(name_or_id, filters=None)`

Get a zone by name or ID.

Parameters:

name_or_id — Name or ID of the zone.
filters — A dictionary of meta data to use for further filtering.

Returns: A zone dict or None if no matching zone is found.

🌈 `global_request(global_request_id)`

Make a new Connection object with a global request id set.

Take the existing settings from the current Connection and construct a new Connection object with the global_request_id overridden.

from oslo_context import context

cloud = openstack.connect(cloud='example')
# Work normally
servers = cloud.list_servers()
cloud2 = cloud.global_request(context.generate_request_id())
# cloud2 sends all requests with global_request_id set
servers = cloud2.list_servers()

Additionally, this can be used as a context manager:

from oslo_context import context

c = openstack.connect(cloud='example')
# Work normally
servers = c.list_servers()
with c.global_request(context.generate_request_id()) as c2:
    # c2 sends all requests with global_request_id set
    servers = c2.list_servers()

Parameters:

global_request_id — The global_request_id to send.

👑 `grant_role(name_or_id, user=None, group=None, project=None, domain=None, system=None, inherited=False, wait=False, timeout=60)`

Grant a role to a user. 💅

Parameters:

name_or_id (string) — Name or unique ID of the role.
user (string) — The name or id of the user.
group (string) — The name or id of the group. (v3)
project (string) — The name or id of the project.
domain (string) — The id of the domain. (v3)
system (bool) — The name of the system. (v3)
inherited (bool) — Whether the role assignment is inherited. (v3)
wait (bool) — Wait for role to be granted.
timeout (int) — Timeout to wait for role to be granted.

NOTE: domain is a required argument when the grant is on a project, user or group specified by name. In that situation, they are all considered to be in that domain. If different domains are in use in the same role grant, it is required to specify those by ID.

NOTE: for wait and timeout, sometimes granting roles is not instantaneous. 😭

NOTE: precedence is given first to project, then domain, then system.

Returns: True if the role is assigned, otherwise False.

Raises: SDKException <#openstack.exceptions.SDKException> if the role cannot be granted.

🧚 `insert_rule_into_policy(name_or_id, rule_name_or_id, insert_after=None, insert_before=None, filters=None)`

Add firewall rule to a policy.

Adds firewall rule to the firewall_rules list of a firewall policy. Short-circuits and returns the firewall policy early if the firewall rule id is already present in the firewall_rules list. This method doesn't do re-ordering. If you want to move a firewall rule or down the list, you have to remove and re-add it. 🫠

Parameters:

name_or_id — firewall policy name or id.
rule_name_or_id — firewall rule name or id.
insert_after — rule name or id that should precede added rule.
insert_before — rule name or id that should succeed added rule.
filters (dict) — optional filters.

Raises: DuplicateResource on multiple matches.

Raises: NotFoundException if firewall policy or any of the firewall rules (inserted, after, before) is not found.

Returns: updated firewall policy.

Return type: FirewallPolicy.

🔥 `inspect_machine(name_or_id, wait=False, timeout=3600)`

Inspect a Barmetal machine.

Engages the Ironic node inspection behavior in order to collect metadata about the baremetal machine.

Parameters:

name_or_id — String representing machine name or UUID value in order to identify the machine.
wait — Boolean value controlling if the method is to wait for the desired state to be reached or a failure to occur.
timeout — Integer value, defaulting to 3600 seconds, for the wait state to reach completion.

Return type: Node <#openstack.baremetal.v1.node.Node>.

Returns: Current state of the node.

🍓 `is_object_stale(container, name, filename, file_md5=None, file_sha256=None)`

Check to see if an object matches the hashes of a file.

Parameters:

container — Name of the container.
name — Name of the object.
filename — Path to the file.
file_md5 — Pre-calculated md5 of the file contents. Defaults to None which means calculate locally.
file_sha256 — Pre-calculated sha256 of the file contents. Defaults to None which means calculate locally.

💜 `is_user_in_group(name_or_id, group_name_or_id)`

Check to see if a user is in a group.

Parameters:

name_or_id — Name or unique ID of the user.
group_name_or_id — Group name or ID.

Returns: True if user is in the group, False otherwise.

Raises: SDKException <#openstack.exceptions.SDKException> if something goes wrong during the OpenStack API call.

⭐ `list_accelerator_requests(filters=None)`

List all accelerator_requests.

Parameters:

filters — (optional) dict of filter conditions to push down.

Returns: A list of accelerator AcceleratorRequest objects.

🎀 `list_aggregates(filters=None)`

List all available host aggregates.

Returns: A list of compute Aggregate objects.

🌸 `list_availability_zone_names(unavailable=False)`

List names of availability zones.

Parameters:

unavailable (bool) — Whether or not to include unavailable zones in the output. Defaults to False.

Returns: A list of availability zone names, or an empty list if the list could not be fetched.

🦋 `list_cluster_templates(detail=False)`

List cluster templates. ✨

detail (bool) — ignored, bestie. Kept purely for backwards compat. ClusterTemplates always come back with full details anyway, no cap.

Returns — a list of dicts holding the cluster template details.

Raises SDKException <#openstack.exceptions.SDKException> if literally anything goes sideways during the OpenStack API call.

`list_coe_clusters()`

List COE (Container Orchestration Engine) clusters. That's the whole vibe.

Returns — a list of container infrastructure management Cluster objects.

Raises SDKException <#openstack.exceptions.SDKException> if something goes wrong during the OpenStack API call. 😭

`list_containers(full_listing=None, prefix=None)`

List containers. Yes like the object store kind. 🫙

Parameters

full_listing — ignored. Present for backwards compat, periodt.
prefix — only objects with this prefix will be returned. (optional)

Returns — a list of object store Container objects.

Raises SDKException <#openstack.exceptions.SDKException> on operation error.

`list_deployables(filters=None)`

List all the available deployables. Every single one. 👑

Parameters

filters — (optional) dict of filter conditions to push down.

Returns — a list of accelerator Deployable objects.

`list_device_profiles(filters=None)`

List all device_profiles — the whole roster.

Parameters

filters — (optional) dict of filter conditions to push down.

Returns — a list of accelerator DeviceProfile objects.

`list_devices(filters=None)`

List all devices. All of them. Every last one. 🔥

Parameters

filters — (optional) dict of filter conditions to push down.

Returns — a list of accelerator Device objects.

`list_domains(**filters)`

List Keystone domains. 🎀

Returns — a list of identity Domain objects.

Raises SDKException <#openstack.exceptions.SDKException> if something goes wrong during the OpenStack API call.

`list_endpoint_groups(**kwargs)`

List Keystone endpoint groups.

Returns — a list of identity EndpointGroup objects.

Raises SDKException <#openstack.exceptions.SDKException> if something goes wrong during the OpenStack API call.

`list_endpoints()`

List Keystone endpoints.

Returns — a list of identity Endpoint objects.

Raises SDKException <#openstack.exceptions.SDKException> if something goes wrong during the OpenStack API call.

`list_firewall_groups(filters=None)`

Lists firewall groups. 🔥🧱

Returns — a list of network FirewallGroup objects.

`list_firewall_policies(filters=None)`

Lists firewall policies.

Parameters

filters —

A dictionary of meta data to use for further filtering. Elements of this dictionary may, themselves, be dictionaries. Example:

{'last_name': 'Smith', 'other': {'gender': 'Female'}}

OR a string containing a jmespath expression for further filtering. Example:

"[?last_name==`Smith`] |
[?other.gender]==`Female`]"

Returns — a list of network FirewallPolicy objects.

Return type — list[FirewallPolicy]

`list_firewall_rules(filters=None)`

Lists firewall rules.

Parameters

filters —

A dictionary of meta data to use for further filtering. Elements of this dictionary may, themselves, be dictionaries. Example:

{'last_name': 'Smith', 'other': {'gender': 'Female'}}

OR a string containing a jmespath expression for further filtering. Example:

"[?last_name==`Smith`] |
[?other.gender]==`Female`]"

Returns — a list of network FirewallRule objects.

Return type — list[FirewallRule]

`list_flavor_access(flavor_id)`

List access from a private flavor for a project/tenant. Private flavors stay private, iykyk. 🙈

Parameters

flavor_id (string) — ID of the private flavor.

Returns — list of dicts with flavor_id and tenant_id attributes.

Raises SDKException <#openstack.exceptions.SDKException> on operation error.

`list_flavors(get_extra=False)`

List all available flavors. 🌈

Parameters

get_extra — whether or not to fetch extra specs for each flavor. The doc says defaults to True (yes, while the signature up there says =False — I'm just the messenger 💀). The default behavior value can be overridden in clouds.yaml by setting openstack.cloud.get_extra_specs to False.

Returns — a list of compute Flavor objects.

`list_floating_ip_pools()`

List all available floating IP pools. 🎈

NOTE: This function supports the nova-net view of the world. nova-net has been deprecated, so it's highly recommended to switch to using neutron. get_external_ipv4_floating_networks is what you should almost certainly be using. Like, seriously bestie.

Returns — a list of floating IP pool objects.

`list_floating_ips(filters=None)`

List all available floating IPs. Floats, but make it cloud. ☁️

Parameters

filters — (optional) dict of filter conditions to push down.

Returns — a list of floating IP openstack.network.v2.floating_ip.FloatingIP.

`list_groups(**kwargs)`

List Keystone groups. Girl groups, but identity. 💅

Parameters

domain_id — domain ID.

Returns — a list of identity Group objects.

Raises SDKException <#openstack.exceptions.SDKException> if something goes wrong during the OpenStack API call.

`list_hypervisors(filters=None)`

List all hypervisors.

Parameters

filters — additional query parameters passed to the API server.

Returns — a list of compute Hypervisor objects.

`list_images(filter_deleted=True, show_all=False)`

Get available images. 📸

Parameters

filter_deleted — control whether deleted images are returned.
show_all — show all images, including images that are shared but not accepted. (By default in glance v2, shared images that have not been accepted are not shown.) show_all will override the value of filter_deleted to False. Yes, override. Watch out for that.

Returns — a list of glance images.

`list_keypairs(filters=None)`

List all available keypairs. 🔑

Parameters

filters

Returns — a list of compute Keypair objects.

`list_machines()`

List Machines. Bare metal ones, main character energy. 🤖

Returns — list of Node <#openstack.baremetal.v1.node.Node>.

`list_magnum_services()`

List all Magnum services.

Returns — a list of dicts containing the service details.

Raises SDKException <#openstack.exceptions.SDKException> on operation error.

`list_networks(filters=None)`

List all available networks. The whole web. 🕸️

Parameters

filters — (optional) a dict of filter conditions to push down.

Returns — a list of network Network objects.

`list_nics()`

Return a list of all bare metal ports.

`list_nics_for_machine(uuid)`

Returns a list of ports present on the machine node.

Parameters

uuid — string representing the machine UUID value, in order to identify the machine.

Returns — a list of ports.

`list_objects(container, full_listing=True, prefix=None)`

List objects. 📦

Parameters

container — name of the container to list objects in.
full_listing — ignored. Present for backwards compat.
prefix — only objects with this prefix will be returned. (optional)

Returns — a list of object store Object objects.

Raises SDKException <#openstack.exceptions.SDKException> on operation error.

`list_ports(filters=None)`

List all available ports. 🔌

Parameters

filters — (optional) a dict of filter conditions to push down.

Returns — a list of network Port objects.

`list_ports_attached_to_machine(name_or_id)`

List virtual ports attached to the bare metal machine. Bestie, note the arg is literally called name_or_id — you get to pick which one. 🫶

name_or_id (string) — a machine name or a UUID, whichever you vibe with.

Returns — a list of openstack.Resource objects that represent the ports. 💖

`list_projects(domain_id=None, name_or_id=None, filters=None)`

List projects. Bestie, this one's a classic ✨

With no parameters at all? It returns a full listing of every visible project. No cap, the whole thing.

Parameters

domain_id — the Domain ID used to scope which projects get searched.
name_or_id — the name or the ID of the project(s) you're after.
filters — a dictionary of meta data for further filtering. Heads up: the elements of this dictionary may themselves be dictionaries, iykyk. Like this:

{'last_name': 'Smith', 'other': {'gender': 'Female'}}

OR — plot twist — it can be a string containing a jmespath expression for further filtering:

"[?last_name==`Smith`] | [?other.gender]==`Female`]"

Returns — a list of identity Project objects.

Raises SDKException (openstack.exceptions.SDKException) if something goes wrong during the OpenStack API call. 😭

`list_qos_bandwidth_limit_rules(policy_name_or_id, filters=None)`

List all the available QoS bandwidth limit rules. 🌈

Parameters

policy_name_or_id (string) — the name or ID of the QoS policy from which rules should be listed.
filters — (optional) a dict of filter conditions to push down.

Returns — a list of network QoSBandwidthLimitRule objects.

Raises ~openstack.exceptions.BadRequestException if the QoS policy will not be found. 🙈

`list_qos_dscp_marking_rules(policy_name_or_id, filters=None)`

List all the available QoS DSCP marking rules. 🎀

Parameters

policy_name_or_id (string) — the name or ID of the QoS policy from which rules should be listed.
filters — (optional) a dict of filter conditions to push down.

Returns — a list of network QoSDSCPMarkingRule objects.

Raises ~openstack.exceptions.BadRequestException if the QoS policy will not be found. 🙈

`list_qos_minimum_bandwidth_rules(policy_name_or_id, filters=None)`

List all the available QoS minimum bandwidth rules. 🌸

Parameters

policy_name_or_id (string) — the name or ID of the QoS policy from which rules should be listed.
filters — (optional) a dict of filter conditions to push down.

Returns — a list of network QoSMinimumBandwidthRule objects.

Raises ~openstack.exceptions.BadRequestException if the QoS policy will not be found. 🙈

`list_qos_policies(filters=None)`

List all the available QoS policies. Periodt. 👑

Parameters

filters — (optional) a dict of filter conditions to push down.

Returns — a list of network QosPolicy objects.

`list_qos_rule_types(filters=None)`

List all the available QoS rule types. Literally all of them. 💅

Parameters

filters — (optional) a dict of filter conditions to push down.

Returns — a list of network QosRuleType objects.

`list_recordsets(zone)`

List all the available recordsets. 🦋

Parameters

zone — the name, the ID, or an openstack.dns.v2.zone.Zone instance of the zone that manages the recordset.

Returns — a list of recordsets.

`list_role_assignments(filters=None)`

List Keystone role assignments. 🌟

Parameters

filters (dict) — a dict of filter conditions. The acceptable keys are:
- 'user' (string) — User ID to be used as the query filter.
- 'group' (string) — Group ID to be used as the query filter.
- 'project' (string) — Project ID to be used as the query filter.
- 'domain' (string) — Domain ID to be used as the query filter.
- 'system' (string) — System name to be used as the query filter.
- 'role' (string) — Role ID to be used as the query filter.
- 'inherited_to' (string) — return inherited role assignments for either 'projects' or 'domains'.
- 'os_inherit_extension_inherited_to' (string) — deprecated, use 'inherited_to' instead. (yes bestie, it's giving legacy 😬)
- 'effective' (boolean) — return effective role assignments.
- 'include_subtree' (boolean) — include subtree.

Heads up: 'user' and 'group' are mutually exclusive, and so are 'domain' and 'project'. Pick a lane. 💀

Returns — a list of identity openstack.identity.v3.role_assignment.RoleAssignment objects.

Raises SDKException (openstack.exceptions.SDKException) if something goes wrong during the OpenStack API call. 😭

`list_roles(**kwargs)`

List Keystone roles. Simple. Iconic. 🎀

Returns — a list of identity Role objects.

Raises SDKException (openstack.exceptions.SDKException) if something goes wrong during the OpenStack API call. 😭

`list_router_interfaces(router, interface_type=None)`

List all the interfaces for a router. 🛜

Parameters

router (dict) — a router dict object.
interface_type (string) — one of None, "internal", or "external". This controls whether all interfaces, internal interfaces, or external interfaces get returned. Your call, bestie ✨

Returns — a list of network Port objects.

`list_routers(filters=None)`

List all the available routers. 🌈

Parameters

filters — (optional) a dict of filter conditions to push down.

Returns — a list of network Router objects.

`list_security_groups(filters=None)`

List all the available security groups. 🛡️

Parameters

filters — (optional) a dict of filter conditions to push down.

Returns — a list of security group openstack.network.v2.security_group.SecurityGroup.

`list_server_groups()`

List all the available server groups. 👯‍♀️

Returns — a list of compute ServerGroup objects.

`list_server_security_groups(server)`

List all the security groups associated with the given server. 🔐

Returns — a list of security group dictionary objects.

`list_servers(detailed=False, all_projects=False, bare=False, filters=None)`

List all the available servers. The main character of listing methods, honestly. 💅

Parameters

detailed — whether or not to add detailed additional information. Defaults to False.
all_projects — whether to list servers from all projects or just the current auth-scoped project.
bare — whether to skip adding any additional information to the server record. Defaults to False, meaning the addresses dict will be populated as needed from neutron. Setting this to True implies detailed = False.
filters — additional query parameters passed to the API server.

Returns — a list of compute Server objects.

`list_services()`

List all Keystone services. ✨

Returns — a list of identity Service object.

Raises SDKException (openstack.exceptions.SDKException) if something goes wrong during the OpenStack API call. 😭

`list_share_availability_zones()`

List all the availability zones for the Shared File Systems service. 🌸

Returns — a list of Shared File Systems Availability Zones.

`list_stacks(**query)`

List all the stacks. 🥞

Parameters

query — query parameters to limit the stacks.

Returns — a list of openstack.orchestration.v1.stack.Stack objects containing the stack description.

Raises SDKException (openstack.exceptions.SDKException) if something goes wrong during the OpenStack API call. 😭

`list_subnets(filters=None)`

List all the available subnets. 🌐

Parameters

filters — (optional) a dict of filter conditions to push down.

Returns — a list of network Subnet objects.

`list_users(**kwargs)`

List users. 🫶

Parameters

name
domain_id — the Domain ID used to scope the retrieved users.

Returns — a list of identity User objects. ✨

Raises SDKException if literally anything goes sideways during the OpenStack API call. 😭

💾 `list_volume_backups(detailed=True, filters=None)`

List out all the volume backups, bestie.

Parameters

detailed — whether or not you want the detailed extra info added on. More is more, honestly.
filters — a dictionary of meta data for further filtering. Example:

{
    'name': 'my-volume-backup',
    'status': 'available',
    'volume_id': 'e126044c-7b4c-43be-a32a-c9cbbc9ddb56',
    'all_tenants': 1,
}

Returns — a list of volume Backup objects. 🎀

📸 `list_volume_snapshots(detailed=True, filters=None)`

Same energy, but for all the volume snapshots.

Parameters

detailed — whether or not to add detailed additional information.
filters — a dictionary of meta data to use for further filtering. Example:

{
    'name': 'my-volume-snapshot',
    'volume_id': 'e126044c-7b4c-43be-a32a-c9cbbc9ddb56',
    'all_tenants': 1,
}

Returns — a list of volume Snapshot objects. 💖

🗂️ `list_volume_types(get_extra=None)`

List every volume type that's available.

Parameters

get_extra — DEPRECATED. This parameter no longer does anything. It's giving legacy, it's giving decorational. 🫠

Returns — a list of volume Type objects.

💽 `list_volumes(cache=None)`

List all the available volumes, periodt.

Parameters

cache — DEPRECATED. This parameter no longer does anything either. Rip bozo, no cap. 💀

Returns — a list of volume Volume objects.

🌍 `list_zones(filters=None)`

List all the available zones.

Returns — a list of zone dicts.

🖥️ `node_set_provision_state(name_or_id, state, configdrive=None, wait=False, timeout=3600)`

Set Node Provision State — the main character method of baremetal setup, honestly.

It lets a user provision a Machine and, if they want, define a config drive to be utilized.

Parameters

name_or_id (string) — the Name or UUID value representing the baremetal node.
state (string) — the desired provision state for the baremetal node.
configdrive (string) — an optional URL or file or path representing the configdrive. In the case of a directory, the client API will create a properly formatted configuration drive file and post the file contents to the API for deployment. She does the formatting for you, so slay. ✨
wait (boolean) — a boolean value, defaulted to false, controlling whether the method waits for the desired end state to be reached before returning.
timeout (integer) — integer value, defaulting to 3600 seconds, representing the amount of time to wait for the desired end state to be reached. That's a whole hour of patience btw.

Returns — the current state of the machine upon exit of the method.

Return type — Node <#openstack.baremetal.v1.node.Node>

Raises SDKException on operation error. 😭

⚡ `patch_accelerator_request(uuid, patch)`

Update an accelerator request.

Parameters

uuid — the UUID of the accelerator request to be updated.
patch — the (patch) that will bind the accelerator.

Returns — True if bind succeeded, False otherwise. Binary queen. 💅

🩹 `patch_machine(name_or_id, patch)`

Patch Machine Information — this one gives you an interface to manipulate node entries within Ironic.

Parameters

name_or_id (string) — a machine name or UUID to be updated.
patch — the JSON Patch document, which is a list of dictionary objects that comply with RFC 6902, found at <https://tools.ietf.org/html/rfc6902>.

Example patch construction:

patch = []
patch.append({'op': 'remove', 'path': '/instance_info'})
patch.append(
    {'op': 'replace', 'path': '/name', 'value': 'newname'}
)
patch.append(
    {
        'op': 'add',
        'path': '/driver_info/username',
        'value': 'administrator',
    }
)

Returns — the current state of the node.

Return type — Node <#openstack.baremetal.v1.node.Node>

Raises SDKException on operation error. 🦋

🎀 `pformat(resource)`

A wrapper around pformat that groks munch objects. Short, sweet, iconic.

🎀 `pprint(resource)`

A wrapper around pprint that groks munch objects. Same vibes, prettier printing. ✨

🧹 `project_cleanup(dry_run=True, wait_timeout=120, status_queue=None, filters=None, resource_evaluation_fn=None, skip_resources=None)`

Cleanup the project resources. Basically the spring cleaning of all spring cleanings.

It cleans up all resources in all services, which provide cleanup methods.

Parameters

dry_run — cleanup, or only list the identified resources. (Spoiler: dry run just lists. Very "looking respectfully" of it. 🙈)
wait_timeout — maximum amount of time given to each service to complete the cleanup.
status_queue — a threading queue object used to get current process status. The queue contains processed resources.
filters — additional filters for the cleanup (only resources matching all filters will be deleted, if there are no other dependencies).
resource_evaluation_fn — a callback function which will be invoked for each resource and must return True/False depending on whether the resource needs to be deleted or not.
skip_resources — list of specific resources whose cleanup should be skipped. Leave my faves alone pls. 💅

🔢 `range_search(data, filters)`

Perform integer range searches across a list of dictionaries. Ngl this one's kind of a flex.

Given a list of dictionaries, it searches across the list using the given dictionary keys and a range of integer values for each key. Only dictionaries that match ALL search filters across the entire original data set will be returned.

It is not a requirement that each dictionary contain the key used for searching. Those without the key will be considered non-matching.

The range values must be string values, and each is either a set of digits representing an integer for matching, or a range operator followed by a set of digits representing an integer for matching. If a range operator is not given, exact value matching will be used. Valid operators are one of: <,>,<=,>=

Parameters

data — list of dictionaries to be searched.
filters — dict describing the one or more range searches to perform. If more than one search is given, the result will be the members of the original data set that match ALL searches. An example of filtering by multiple ranges:

{"vcpus": "<=5", "ram": "<=2048", "disk": "1"}

Returns — a list subset of the original data set.

Raises SDKException on invalid range expressions. 🚨

🔨 `rebuild_server(server_id, image_id, admin_pass=None, detailed=False, bare=False, wait=False, timeout=180)`

Rebuild a server. Fresh start, new you, etc.

Parameters

server_id
image_id
admin_pass
detailed
bare
wait
timeout

Returns — a compute Server object.

🏗️ `register_machine(nics, wait=False, timeout=3600, lock_timeout=600, provision_state='available', **kwargs)`

Register Baremetal with Ironic — okay this one ate, fr fr.

It allows for the registration of Baremetal nodes with Ironic and population of pertinent node information or configuration to be passed to the Ironic API for the node.

This method also creates ports for a list of MAC addresses passed in, to be utilized for boot and potentially network configuration. Ports! Plural! 🫶

If a failure is detected creating the network ports, any ports created are deleted, and the node is removed from Ironic. It cleans up after itself, we love a self-aware icon. ✨

Parameters

nics —
An array of ports that represent the network interfaces for the node we're creating — and the timing matters, bestie: these ports get created after the node is enrolled but before it heads off into cleaning 🧼

Example:

[
    {'address': 'aa:bb:cc:dd:ee:01'},
    {'address': 'aa:bb:cc:dd:ee:02'},
]

Alternatively you can just pass an array of MAC addresses. Lowkey easier, tbh 💅

wait — Boolean value, defaults to false, and it makes the method wait for the node to reach the available state, y'know, the state where the node can actually be provisioned. But important caveat, so listen up 👀: when it's set to false, the method will still wait for locks to clear before it sends the next required command. So there's no fully skipping the lock wait, ever, periodt.
timeout — Integer value, defaults to 3600 seconds, for the wait state to reach completion. Give it an hour, she'll get there ✨
lock_timeout — Integer value, defaults to 600 seconds, for locks to clear.
provision_state — the expected provision state, one of "enroll", "manageable" or "available". Heads up: using "available" results in automated cleaning 🧽
kwargs — key value pairs that get passed along to the Ironic API, including uuid, name, chassis_uuid, driver_info, properties.

Returns

Current state of the node.

Return type

Node <#openstack.baremetal.v1.node.Node>.

Raises

SDKException <#openstack.exceptions.SDKException> on operation error.

`remove_flavor_access(flavor_id, project_id)`

Revoke access from a private flavor for a project/tenant. Bye-bye access 👋

Parameters

flavor_id (string) — ID of the private flavor.
project_id (string) — ID of the project/tenant.

Returns

None

Raises

SDKException <#openstack.exceptions.SDKException> on operation error.

`remove_host_from_aggregate(name_or_id, host_name)`

Remove a host from an aggregate. Just yeet it out of the group 🫶

Parameters

name_or_id — name or ID of the host aggregate.
host_name — host to remove.

Raises

SDKException <#openstack.exceptions.SDKException> on operation error.

`remove_machine_from_maintenance(name_or_id)`

Remove Baremetal Machine from Maintenance State 🔧

Very much the mirror twin of set_machine_maintenance_state — this method removes a machine from maintenance state. And ngl, the way it works is charmingly lazy: it simply calls set_machine_maintenace_state for the name_or_id you requested and sets the state to False. That's it, that's the whole trick 💀

Parameters

name_or_id (string) — the Name or UUID value representing the baremetal node.

Returns

None

Raises

SDKException <#openstack.exceptions.SDKException> on operation error.

`remove_router_interface(router, subnet_id=None, port_id=None)`

Detach a subnet from an internal router interface ✂️

At least one of subnet_id or port_id must be supplied. Non-negotiable, bestie.

And if you specify both subnet and port ID, the subnet ID must correspond to the subnet ID of the first IP address on the port specified by the port ID. Otherwise an error occurs. Like, an actual error 😭

Parameters

router (dict) — the dict object of the router being changed.
subnet_id (string) — the ID of the subnet to use for the interface.
port_id (string) — the ID of the port to use for the interface.

Returns

None on success.

Raises

SDKException <#openstack.exceptions.SDKException> on operation error.

`remove_rule_from_policy(name_or_id, rule_name_or_id, filters=None)`

Remove a firewall rule from a firewall policy's firewall_rules list. And the icon move here: it short-circuits and returns the firewall policy early if the firewall rule is already absent from the firewall_rules list. Efficient queen 👑

Parameters

name_or_id — firewall policy name or id.
rule_name_or_id — firewall rule name or id.
filters (dict) — optional filters.

Raises

DuplicateResource on multiple matches.

Raises

NotFoundException if firewall policy is not found.

Returns

Updated firewall policy.

Return type

FirewallPolicy

`remove_server_security_groups(server, security_groups)`

Remove security groups from a server 🛡️

Remove existing security groups from an existing server. And the chill part: if the security groups aren't even present on the server, this will continue unaffected. No drama, no crash 💅

Parameters

server — the server to remove security groups from.
security_groups — a list of security groups to remove.

Returns

False if server or security groups are undefined, True otherwise.

Raises

SDKException <#openstack.exceptions.SDKException> on operation error.

`remove_user_from_group(name_or_id, group_name_or_id)`

Remove a user from a group. Sorry bestie, you're out of the group chat 🚪

Parameters

name_or_id — name or unique ID of the user.
group_name_or_id — group name or ID.

Raises

SDKException <#openstack.exceptions.SDKException> if something goes wrong during the OpenStack API call.

`remove_volume_type_access(name_or_id, project_id)`

Revoke access on a volume_type to a project. Access: revoked. Vibe: immaculate ✨

Parameters

name_or_id — ID or name of a volume_type.
project_id — a project id.

Returns

None

Raises

SDKException <#openstack.exceptions.SDKException> on operation error.

`revoke_role(name_or_id, user=None, group=None, project=None, domain=None, system=None, inherited=False, wait=False, timeout=60)`

Revoke a role from a user. Taking the crown back 👑

Parameters

name_or_id (string) — name or unique ID of the role.
user (string) — the name or id of the user.
group (string) — the name or id of the group. (v3)
project (string) — the name or id of the project.
domain (string) — the id of the domain. (v3)
system (bool) — the name of the system. (v3)
inherited (bool) — whether the role assignment is inherited.
wait (bool) — wait for role to be revoked.
timeout (int) —

Timeout to wait for role to be revoked.

NOTE: for wait and timeout, sometimes revoking roles is not instantaneous. Patience, gorgeous 🫶

NOTE: project is required for keystone v2.

NOTE: precedence is given first to project, then domain, then system.

Returns

True if the role is revoked, otherwise False.

Raises

SDKException <#openstack.exceptions.SDKException> if the role cannot be removed.

`search_aggregates(name_or_id=None, filters=None)`

Search host aggregates 🔍 (the original page says "Seach", and honestly? she's searching for her keys, we love her anyway 💀)

Parameters

name — aggregate name or id.
filters (dict) —

A dictionary of meta data to use for further filtering. Elements of this dictionary may, themselves, be dictionaries. Example:

{
    'availability_zone': 'nova',
    'metadata': {'cpu_allocation_ratio': '1.0'},
}

Returns

A list of compute Aggregate objects matching the search criteria.

Raises

SDKException <#openstack.exceptions.SDKException> if something goes wrong during the OpenStack API call.

`search_cluster_templates(name_or_id=None, filters=None, detail=False)`

Search cluster templates 🌸

Parameters

name_or_id — cluster template name or ID.
filters — a dict containing additional filters to use.
detail — a boolean to control if we need summarized or detailed output.

Returns

A list of dict containing the cluster templates.

Raises

SDKException <#openstack.exceptions.SDKException>: if something goes wrong during the OpenStack API call.

`search_coe_clusters(name_or_id=None, filters=None)`

Search COE cluster 🐝 (container orchestration energy, iykyk)

Parameters

name_or_id — cluster name or ID.
filters — a dict containing additional filters to use.
detail — a boolean to control if we need summarized or detailed output.

Returns

A list of container infrastructure management Cluster objects.

Raises SDKException (that's openstack.exceptions.SDKException, bestie) — only if something goes totally sideways during the OpenStack API call. 😭

`search_containers(name=None, filters=None)`

Search containers. Your lil treasure hunt through the object store 💖

search_containers(name=None, filters=None)

Parameters

name (string) — Container name.
filters — A dict containing additional filters to use. OR a string containing a jmespath expression for further filtering. Example:

"[?last_name==`Smith`] | [?other.gender]==`Female`]"

Returns — A list of object store Container objects matching the search criteria.

Raises SDKException: if something goes wrong during the OpenStack API call.

`search_domains(filters=None, name_or_id=None)`

Search Keystone domains. 👑

search_domains(filters=None, name_or_id=None)

Parameters

name_or_id — Name or ID of the domain(s).
filters — dictionary of meta data to use for further filtering. Elements of this dictionary may, themselves, be dictionaries. Example:

{'last_name': 'Smith', 'other': {'gender': 'Female'}}

OR a string containing a jmespath expression for further filtering. Example:

"[?last_name==`Smith`] | [?other.gender]==`Female`]"

Returns — a list of identity Domain objects.

Raises SDKException if something goes wrong during the OpenStack API call.

`search_endpoint_groups(name_or_id=None, filters=None)`

Search Keystone endpoint groups. Grouping endpoints together = iconic behaviour, no cap ✨

search_endpoint_groups(name_or_id=None, filters=None)

Parameters

name_or_id — Name or ID of the endpoint group(s).
filters — dictionary of meta data to use for further filtering. Elements of this dictionary may, themselves, be dictionaries. Example:

{'last_name': 'Smith', 'other': {'gender': 'Female'}}

OR a string containing a jmespath expression for further filtering. Example:

"[?last_name==`Smith`] | [?other.gender]==`Female`]"

Returns — A list of identity EndpointGroup objects.

Raises SDKException if something goes wrong during the OpenStack API call.

`search_endpoints(id=None, filters=None)`

List Keystone endpoints. Slightly different flavour from the others — this one takes an id, not a name_or_id. Read the signature, babe 🫶

search_endpoints(id=None, filters=None)

Parameters

id — ID of endpoint(s).
filters — dictionary of meta data to use for further filtering. Elements of this dictionary may, themselves, be dictionaries. Example:

{'last_name': 'Smith', 'other': {'gender': 'Female'}}

OR a string containing a jmespath expression for further filtering. Example:

"[?last_name==`Smith`] | [?other.gender]==`Female`]"

Returns — A list of identity Endpoint objects.

Raises SDKException if something goes wrong during the OpenStack API call.

`search_flavors(name_or_id=None, filters=None, get_extra=True)`

Search flavors. Get you a flavor that fits 💅

search_flavors(name_or_id=None, filters=None, get_extra=True)

Parameters

name_or_id — Name or unique ID of the flavor(s).
filters — (yep, that's the whole description, she's mysterious like that 🙈)
get_extra — Whether to fetch extra specs.

Returns — A list of compute Flavor objects matching the search criteria.

Heads up: no Raises listed for this one — don't go inventing one. 😌

`search_groups(name_or_id=None, filters=None, domain_id=None)`

Search Keystone groups. Besties of the identity world 🌸

search_groups(name_or_id=None, filters=None, domain_id=None)

Parameters

name_or_id — Name or ID of the group(s).
filters — dictionary of meta data to use for further filtering. Elements of this dictionary may, themselves, be dictionaries. Example:

{'last_name': 'Smith', 'other': {'gender': 'Female'}}

OR a string containing a jmespath expression for further filtering. Example:

"[?last_name==`Smith`] | [?other.gender]==`Female`]"

domain_id — Domain ID to scope the searched groups.

Returns — A list of identity Group objects.

Raises SDKException if something goes wrong during the OpenStack API call.

`search_keypairs(name_or_id=None, filters=None)`

Search keypairs. 🔑 Lowkey the most useful search ever.

search_keypairs(name_or_id=None, filters=None)

Parameters

name_or_id — Name or unique ID of the keypair(s).
filters — A dictionary of meta data to use for further filtering. Elements of this dictionary may, themselves, be dictionaries. Example:

{'last_name': 'Smith', 'other': {'gender': 'Female'}}

OR a string containing a jmespath expression for further filtering. Invalid filters will be ignored. (noted. behaviour check: they get dropped, not errored 🫡)

Returns — A list of compute Keypair objects matching the search criteria.

Raises SDKException if something goes wrong during the OpenStack API call.

`search_networks(name_or_id=None, filters=None)`

Search networks. Networking era 🦋

search_networks(name_or_id=None, filters=None)

Parameters

name_or_id — Name or ID of the desired network.
filters — A dict containing additional filters to use, e.g. {'router:external': True}

Returns — A list of network Network objects matching the search criteria.

Raises SDKException if something goes wrong during the OpenStack API call.

`search_objects(container, name=None, filters=None)`

Search objects. Note the required container first — objects live inside containers, she's not optional ✨

search_objects(container, name=None, filters=None)

Parameters

name (string) — Object name.
filters — A dict containing additional filters to use. OR a string containing a jmespath expression for further filtering. Example:

"[?last_name==`Smith`] | [?other.gender]==`Female`]"

Returns — A list of object store Object objects matching the search criteria.

Raises SDKException: if something goes wrong during the OpenStack API call.

`search_ports(name_or_id=None, filters=None)`

Search ports. The little connectors that carry everything 🎀

search_ports(name_or_id=None, filters=None)

Parameters

name_or_id — Name or ID of the desired port.
filters — A dict containing additional filters to use, e.g. {'device_id': '2711c67a-b4a7-43dd-ace7-6187b791c3f0'} (yes, that UUID is exactly correct, don't retype it, copy it 😭)

Returns — A list of network Port objects matching the search criteria.

Raises SDKException if something goes wrong during the OpenStack API call.

`search_projects(name_or_id=None, filters=None, domain_id=None)`

Backwards compatibility method for search_projects. 🫶

Okay so the lore: search_projects originally had a parameter list that was name_or_id, filters, and list had domain_id first. This method exists in this form to allow code written with positional parameters to still work. But really — use keyword arguments. Fr fr, use keyword arguments.

search_projects(name_or_id=None, filters=None, domain_id=None)

Parameters

name_or_id — Name or ID of the project(s).
filters — dictionary of meta data to use for further filtering. Elements of this dictionary may, themselves, be dictionaries. Example:

{'last_name': 'Smith', 'other': {'gender': 'Female'}}

OR a string containing a jmespath expression for further filtering. Example:

"[?last_name==`Smith`] | [?other.gender]==`Female`]"

domain_id — Domain ID to scope the searched projects.

Returns — A list of identity Project objects.

No Raises block on this one in the source — so I'm not adding one. Periodt. 💅

`search_qos_bandwidth_limit_rules(policy_name_or_id, rule_id=None, filters=None)`

Search QoS bandwidth limit rules. Bandwidth, but make it governed 🔥

search_qos_bandwidth_limit_rules(policy_name_or_id, rule_id=None,
        filters=None)

Parameters

policy_name_or_id (string) — Name or ID of the QoS policy to which rules should be associated.
rule_id (string) — ID of searched rule.
filters — a dict containing additional filters to use, e.g. {'max_kbps': 1000}

Returns — A list of network QoSBandwidthLimitRule objects matching the search criteria.

Raises SDKException if something goes wrong during the OpenStack API call.

`search_qos_dscp_marking_rules(policy_name_or_id, rule_id=None, filters=None)`

Search QoS DSCP marking rules

policy_name_or_id (string) — the name or the ID of the QoS policy these rules are supposed to be attached to 🫶
rule_id (string) — the ID of the rule we're hunting for
filters — a dict of extra filters to narrow stuff down, like {'dscp_mark': 32}

Returns — a list of network QoSDSCPMarkingRule objects that match what you asked for ✨

Raises SDKException <#openstack.exceptions.SDKException> if anything goes sideways during the OpenStack API call 😭

`search_qos_minimum_bandwidth_rules(policy_name_or_id, rule_id=None, filters=None)`

Search QoS minimum bandwidth rules, lowkey the bandwidth bouncers of the network 💅

Parameters

policy_name_or_id (string) — name or ID of the QoS policy the rules belong to
rule_id (string) — ID of the rule you're searching for
filters — a dict of extra filters, e.g. {'min_kbps': 1000}

Returns — a list of network QoSMinimumBandwidthRule objects matching the search criteria 🌸

Raises SDKException <#openstack.exceptions.SDKException> if something goes wrong during the OpenStack API call

`search_qos_policies(name_or_id=None, filters=None)`

Search QoS policies, the main character energy of network traffic shaping 👑

Parameters

name_or_id — name or ID of the policy you want
filters — a dict of extra filters, e.g. {'shared': True}

Returns — a list of network QosPolicy objects matching the search criteria ✨

Raises SDKException <#openstack.exceptions.SDKException> if something goes wrong during the OpenStack API call

`search_resources(resource_type, name_or_id, get_args=None, get_kwargs=None, list_args=None, list_kwargs=None, **filters)`

Search resources — like, search resources that match certain conditions, bestie 🔍

Parameters

resource_type — a string version of the resource you expect, written as service.resource (so like "network.security_group")
name_or_id — name or ID of the resource
get_args — optional args passed along to the _get call
get_kwargs — optional kwargs passed along to the _get call
list_args — optional args passed along to the _list call
list_kwargs — optional kwargs passed along to the _list call
filters — extra filters used when querying resources

`search_roles(name_or_id=None, filters=None, domain_id=None)`

Search Keystone roles 🎀

Parameters

name — name or ID of the role(s)
filters —

a dictionary of meta data for further filtering. The elements of this dictionary may themselves be dictionaries too. Example:

{'last_name': 'Smith', 'other': {'gender': 'Female'}}

a string holding a jmespath expression for further filtering. Example:

"[?last_name==`Smith`] | [?other.gender]==`Female`]"

domain_id — domain ID used to scope the searched roles

Returns — a list of identity Role objects 💖

Raises SDKException <#openstack.exceptions.SDKException> if something goes wrong during the OpenStack API call

`search_routers(name_or_id=None, filters=None)`

Search routers 🌈

Parameters

name_or_id — name or ID of the router you want
filters — a dict of extra filters, e.g. {'admin_state_up': True}

Returns — a list of network Router objects matching the search criteria

Raises SDKException <#openstack.exceptions.SDKException> if something goes wrong during the OpenStack API call

`search_server_groups(name_or_id=None, filters=None)`

Search server groups, we love a squad 🫶

Parameters

name_or_id — name or unique ID of the server group(s)
filters —

a dictionary of meta data for further filtering. Elements of this dictionary may, themselves, be dictionaries. Example:

{'last_name': 'Smith', 'other': {'gender': 'Female'}}

a string containing a jmespath expression for further filtering. Invalid filters get ignored, no cap 🙈

Returns — a list of compute ServerGroup objects matching the search criteria ✨

Raises SDKException <#openstack.exceptions.SDKException> if something goes wrong during the OpenStack API call

`search_servers(name_or_id=None, filters=None, detailed=False, all_projects=False, bare=False)`

Search servers — the whole server roster 🔥

Parameters

name_or_id — name or unique ID of the server(s)
filters —

a dictionary of meta data for further filtering. Elements of this dictionary may, themselves, be dictionaries. Example:

{'last_name': 'Smith', 'other': {'gender': 'Female'}}

a string containing a jmespath expression for further filtering. Invalid filters will be ignored 💀

detailed
all_projects
bare

Returns — a list of compute Server objects matching the search criteria ⭐

`search_services(name_or_id=None, filters=None)`

Search Keystone services 🌸

Parameters

name_or_id — name or ID of the service(s)
filters —

a dictionary of meta data for further filtering. The elements of this dictionary may themselves be dictionaries. Example:

{'last_name': 'Smith', 'other': {'gender': 'Female'}}

a string containing a jmespath expression for further filtering. Example:

"[?last_name==`Smith`] | [?other.gender]==`Female`]"

Returns — a list of identity Service objects 💜

Raises SDKException <#openstack.exceptions.SDKException> if something goes wrong during the OpenStack API call

`search_stacks(name_or_id=None, filters=None)`

Search stacks, orchestration girlies rise 🧚

Parameters

name_or_id — name or ID of the stack you want
filters — a dict of extra filters, e.g. {'stack_status': 'CREATE_COMPLETE'}

Returns — a list of openstack.orchestration.v1.stack.Stack containing the stack description

Raises SDKException <#openstack.exceptions.SDKException> if something goes wrong during the OpenStack API call

`search_subnets(name_or_id=None, filters=None)`

Search subnets 🌐

Parameters

name_or_id — name or ID of the subnet you want
filters — a dict of extra filters, e.g. {'enable_dhcp': True}

Returns — a list of network Subnet objects matching the search criteria

Raises SDKException <#openstack.exceptions.SDKException> if something goes wrong during the OpenStack API call

`search_users(name_or_id=None, filters=None, domain_id=None)`

Search users, the people of the cloud 🎀

Parameters

name_or_id — name or ID of the user(s)
domain_id — domain ID used to scope the retrieved users
filters —

a dictionary of meta data for further filtering. Elements of this dictionary may, themselves, be dictionaries. Example:

{'last_name': 'Smith', 'other': {'gender': 'Female'}}

a string containing a jmespath expression for further filtering. Example:

"[?last_name==`Smith`] | [?other.gender]==`Female`]"

Returns — a list of identity User objects 💖

Raises SDKException <#openstack.exceptions.SDKException> if something goes wrong during the OpenStack API call

`search_volume_backups(name_or_id=None, filters=None)`

Search for one or more volume backups, so you never lose the precious data 🍓

Parameters

name_or_id — name or unique ID of the volume backup(s)
filters —
filters — DEPRECATED bestie it's a whole dictionary of meta data you can use for further filtering. Elements of this dictionary may, themselves, be dictionaries. Example:

{'last_name': 'Smith', 'other': {'gender': 'Female'}}

A string containing a jmespath expression for further filtering. Example:

"[?last_name==`Smith`] | [?other.gender]==`Female`]"

Returns — a list of volume Backup objects, if any are found. 🫶

`search_volume_snapshots(name_or_id=None, filters=None)` 🫙

Search for one or more volume snapshots. Iconic little lookup, no notes.

Parameters

name_or_id — name or unique ID of the volume snapshot(s).
filters — DEPRECATED a dictionary of meta data to use for further filtering. Elements of this dictionary may, themselves, be dictionaries. Example:

{'last_name': 'Smith', 'other': {'gender': 'Female'}}

A string containing a jmespath expression for further filtering. Example:

"[?last_name==`Smith`] | [?other.gender]==`Female`]"

Returns — a list of volume Snapshot objects, if any are found. ✨

`search_volume_types(name_or_id=None, filters=None, get_extra=None)` 🧊

Search for one or more volume types.

Parameters

name_or_id — name or unique ID of the volume type(s).
filters — DEPRECATED a dictionary of meta data to use for further filtering. Elements of this dictionary may, themselves, be dictionaries. Example:

{'last_name': 'Smith', 'other': {'gender': 'Female'}}

A string containing a jmespath expression for further filtering. Example:

"[?last_name==`Smith`] | [?other.gender]==`Female`]"

Returns — a list of volume Type objects, if any are found.

Yes, get_extra=None is in the signature, and nope, the page doesn't say anything else about it. That's the whole vibe check. 💀

`search_volumes(name_or_id=None, filters=None)` 🌊

Search for one or more volumes. The classic.

Parameters

name_or_id — name or unique ID of the volume(s).
filters — DEPRECATED a dictionary of meta data to use for further filtering. Elements of this dictionary may, themselves, be dictionaries. Example:

{'last_name': 'Smith', 'other': {'gender': 'Female'}}

A string containing a jmespath expression for further filtering. Example:

"[?last_name==`Smith`] | [?other.gender]==`Female`]"

Returns — a list of volume Volume objects, if any are found. 💖

`set_aggregate_metadata(name_or_id, metadata)` 🏗️

Set aggregate metadata, replacing the existing metadata. Not merging — replacing, so read that twice before you run it, fr fr.

Parameters

name_or_id — name of the host aggregate to update.
metadata — dict containing metadata to replace. Pro tip straight from the page: use {'key': None} to remove a key.

Returns — a dict representing the new host aggregate.

Raises SDKException <#openstack.exceptions.SDKException> on operation error.

`set_compute_quotas(name_or_id, **kwargs)` 📊

Set a quota in a project.

Parameters

name_or_id — project name or id.
kwargs — key/value pairs of quota name and quota value.

Raises SDKException <#openstack.exceptions.SDKException> if the resource to set the quota does not exist.

`set_container_access(name, access, refresh=False)` 🔐

Set the access control list on a container.

Parameters

name (str) — name of the container.
access (str) — ACL string to set on the container. Can also be public or private, which will be translated into appropriate ACL strings. Slay.
refresh — flag to trigger refresh of the container properties.

`set_flavor_specs(flavor_id, extra_specs)` 🍦

Add extra specs to a flavor.

Parameters

flavor_id (string) — ID of the flavor to update.
extra_specs (dict) — dictionary of key-value pairs.

Returns — None.

Raises SDKException <#openstack.exceptions.SDKException> on operation error.

Raises BadRequestException <#openstack.exceptions.BadRequestException> if flavor ID is not found.

`set_machine_maintenance_state(name_or_id, state=True, reason=None)` 🛠️

Set Baremetal Machine Maintenance State.

Sets the Baremetal maintenance state and the maintenance reason. Two-for-one.

Parameters

name_or_id (string) — the Name or UUID value representing the baremetal node.
state (boolean) — the desired state of the node. True being in maintenance, whereas False means the machine is not in maintenance mode. This value defaults to True if not explicitly set.
reason (string) — an optional freeform string that is supplied to the baremetal API to allow for notation as to why the node is in maintenance state. Receipts, basically. 🧾

Returns — None.

Raises SDKException <#openstack.exceptions.SDKException> on operation error.

`set_machine_power_off(name_or_id)` 🔌

De-activate baremetal machine power.

This is a method that sets the node power state to "off". That's it, that's the whole thing.

Parameters

name_or_id — a string representing the baremetal node to have power turned to an "off" state.

Returns — None.

Raises SDKException <#openstack.exceptions.SDKException> on operation error.

`set_machine_power_on(name_or_id)` ⚡

Activate baremetal machine power.

This is a method that sets the node power state to "on". The comeback era.

Parameters

name_or_id — a string representing the baremetal node to have power turned to an "on" state.

Returns — None.

Raises SDKException <#openstack.exceptions.SDKException> on operation error.

`set_machine_power_reboot(name_or_id)` 🔁

De-activate baremetal machine power.

(Yes, that's the summary line the page gives it. Not me, I'm just the messenger. 🙈)

This is a method that sets the node power state to "reboot", which in essence changes the machine power state to "off", and then back to "on". Glow-down, glow-up, immediately.

Parameters

name_or_id — a string representing the baremetal node to have power turned to an "off" state.

Returns — None.

Raises SDKException <#openstack.exceptions.SDKException> on operation error.

`set_network_quotas(name_or_id, **kwargs)` 🌐

Set a network quota in a project.

Parameters

name_or_id — project name or id.
kwargs — key/value pairs of quota name and quota value.

Raises SDKException <#openstack.exceptions.SDKException> if the resource to set the quota does not exist.

`set_server_metadata(name_or_id, metadata)` 🖥️

Set metadata in a server instance.

Parameters

name_or_id (str) — the name or ID of the server instance to update.
metadata (dict) — a dictionary with the key=value pairs to set in the server instance. It only updates the key=value pairs provided. Existing ones will remain untouched. Non-destructive, we love to see it. 🫶

Returns — None.

Raises SDKException <#openstack.exceptions.SDKException> on operation error.

`set_volume_bootable(name_or_id, bootable=True)` 👢

Set a volume's bootable flag.

Parameters

name_or_id — name or unique ID of the volume.
bootable (bool) — whether the volume should be bootable. (Defaults to True.)

Returns — None.

Raises ResourceTimeout <#openstack.exceptions.ResourceTimeout> if wait time exceeded.

Raises SDKException <#openstack.exceptions.SDKException> on operation error.

`set_volume_quotas(name_or_id, **kwargs)` 💾

Set a volume quota in a project.

Parameters

name_or_id — project name or id.
kwargs — key/value pairs of quota name and quota value.

Returns — None.

Raises SDKException <#openstack.exceptions.SDKException> if the resource to set the quota does not exist.

`sign_coe_cluster_certificate(cluster_id, csr)` 🎀

Sign client key and generate the CA certificate for a cluster. Very main character certificate behaviour, ngl.

Parameters

cluster_id — UUID of the cluster.
csr — Certificate Signing Request (CSR) for authenticating client key. The CSR will be used by Magnum to generate a signed certificate that client will use to communicate with the cluster.

Returns — a dict representing the signed certs.

Raises — SDKException <#openstack.exceptions.SDKException> on operation error.

🦋 `stream_object(container, obj, query_string=None, resp_chunk_size=1024)`

Download the content via a streaming iterator. Very demure, very streamy.

Parameters

container (string) — Name of the container.
obj (string) — Name of the object.
query_string (string) — Query args for uri. (delimiter, prefix, etc.)
resp_chunk_size (int) — Chunk size of data to read. Only used if the results are

Returns — An iterator over the content or None if the object is not found.

Raises — SDKException <#openstack.exceptions.SDKException> on operation error.

🧚 `unbind_accelerator_request(uuid, properties)`

Unbind an accelerator from VM.

A deprecated alias for patch_accelerator_request. It's giving legacy, bestie — still here, still working.

💜 `unregister_machine(nics, uuid, wait=None, timeout=600)`

Unregister Baremetal from Ironic. Removes entries for Network Interfaces and baremetal nodes from an Ironic API.

Parameters

nics — An array of strings that consist of MAC addresses to be removed.
uuid (string) — The UUID of the node to be deleted.
wait — DEPRECATED, do not use.
timeout — Integer value, representing seconds with a default value of 600, which controls the maximum amount of time to block until a lock is released on machine.

Raises — SDKException <#openstack.exceptions.SDKException> on operation failure.

🌸 `unset_flavor_specs(flavor_id, keys)`

Delete extra specs from a flavor. Marie Kondo energy fr fr.

Parameters

flavor_id (string) — ID of the flavor to update.
keys — List of spec keys to delete.

Returns — None

Raises — SDKException <#openstack.exceptions.SDKException> on operation error.

Raises — BadRequestException <#openstack.exceptions.BadRequestException> if flavor ID is not found.

✨ `update_aggregate(name_or_id, **kwargs)`

Update a host aggregate.

Parameters

name_or_id — Name or ID of the aggregate being updated.
name — New aggregate name
availability_zone — Availability zone to assign to hosts

Returns — The updated compute Aggregate object.

Raises — SDKException <#openstack.exceptions.SDKException> on operation error.

🎀 `update_cluster_template(name_or_id, **kwargs)`

Update a cluster template.

Parameters

name_or_id — Name or ID of the cluster template being updated.

Returns — an update cluster template.

Raises — SDKException <#openstack.exceptions.SDKException> on operation error.

👑 `update_coe_cluster(name_or_id, **kwargs)`

Update a COE cluster.

Parameters

name_or_id — Name or ID of the COE cluster being updated.
kwargs — Cluster attributes to be updated.

Returns — The updated cluster Cluster object.

Raises — SDKException <#openstack.exceptions.SDKException> on operation error.

🍓 `update_container(name, headers)`

Update the metadata in a container.

Parameters

name (str) — Name of the container to update.
headers (dict) — Key/Value headers to set on the container.

🌈 `update_domain(domain_id=None, name=None, description=None, enabled=None, name_or_id=None)`

Update a Keystone domain.

Parameters

domain_id
name
description
enabled
name_or_id — Name or unique ID of the domain.

Returns — The updated identity Domain object.

Raises — SDKException <#openstack.exceptions.SDKException> if the domain cannot be updated

💅 `update_firewall_group(name_or_id, filters=None, **kwargs)`

Updates firewall group. To unset egress- or ingress firewall policy, set egress_firewall_policy or ingress_firewall_policy to None. You can also set egress_firewall_policy_id and ingress_firewall_policy_id directly, which will skip the policy lookups.

Parameters

name_or_id — firewall group name or id
filters (dict) — optional filters
kwargs — firewall group update parameters See create_firewall_group docstring for valid parameters.

Returns — The updated network FirewallGroup object.

Raises — BadRequestException if parameters are malformed

Raises — DuplicateResource on multiple matches

Raises — NotFoundException if firewall group, a firewall policy (egress, ingress) or port is not found

🔥 `update_firewall_policy(name_or_id, filters=None, **kwargs)`

Updates firewall policy.

Parameters

name_or_id — firewall policy name or id
filters —

A dictionary of meta data to use for further filtering. Elements of this dictionary may, themselves, be dictionaries. Example:

{'last_name': 'Smith', 'other': {'gender': 'Female'}}

OR A string containing a jmespath expression for further filtering. Example:

"[?last_name==`Smith`] | [?other.gender]==`Female`]"

kwargs — firewall policy update parameters See create_firewall_policy docstring for valid parameters.

Returns — The updated network FirewallPolicy object.

Raises — BadRequestException if parameters are malformed

Raises — DuplicateResource on multiple matches

Raises — NotFoundException if resource is not found

🦋 `update_firewall_rule(name_or_id, filters=None, **kwargs)`

Updates firewall rule.

Parameters

name_or_id — firewall rule name or id
filters —

A dictionary of meta data to use for further filtering. Elements of this dictionary may, themselves, be dictionaries. Example:

{'last_name': 'Smith', 'other': {'gender': 'Female'}}

OR A string containing a jmespath expression for further filtering. Example:

"[?last_name==`Smith`] | [?other.gender]==`Female`]"

kwargs — firewall rule update parameters. See create_firewall_rule docstring for valid parameters.

Returns — The updated network FirewallRule object.

Raises — BadRequestException if parameters are malformed

Raises — NotFoundException if resource is not found

💖 `update_group(name_or_id, name=None, description=None, **kwargs)`

Update an existing group.

Parameters

name_or_id — Name or unique ID of the group.
name — New group name.
description — New group description.

Returns — The updated identity Group object.

Raises — SDKException <#openstack.exceptions.SDKException> if something goes wrong during the OpenStack API call.

⭐ `update_machine(name_or_id, **attrs)`

Update a machine with new configuration information. A user-friendly method to perform updates of a machine, in whole or part.

Parameters

name_or_id (string) — A machine name or UUID to be updated.
attrs — Attributes to updated on the machine.

Returns — A dictionary containing a machine sub-dictionary consisting of the updated data returned from the API update operation, and a list named changes which contains all of the API paths that received updates.

Raises — SDKException <#openstack.exceptions.SDKException> on operation error.

🌸 `update_network(name_or_id, **kwargs)`

Update a network.

Parameters

name_or_id (string) — Name or ID of the network being updated.
name (string) — New name of the network.
shared (bool) — Set the network as shared.
admin_state_up (bool) — Set the network administrative state to up.
external (bool) — is this network externally accessible? yes or no, bestie.
provider (dict) — a dict of network provider options. Example:

{'network_type': 'vlan', 'segmentation_id': 'vlan1'}

mtu_size (int) — new maximum transmission unit value, here to address fragmentation. Minimum value is 68 for IPv4, and 1280 for IPv6. 🫶
port_security_enabled (bool) — enable or disable port security.
dns_domain (string) — specify the DNS domain associated with this network.

Returns: the updated network Network object. ✨

Raises: SDKException <#openstack.exceptions.SDKException> on operation error.

🎀 `update_object(container, name, metadata=None, **headers)`

Update the metadata of an object.

Parameters:

container — the name of the container the object is in.
name — name for the object within the container.
metadata — this dict will get changed into headers that set metadata of the object.
headers — these will be passed through to the object update API as HTTP Headers.

Returns: None.

Raises: SDKException <#openstack.exceptions.SDKException> on operation error.

🦋 `update_port(name_or_id, **kwargs)`

Update a port.

Note: to unset an attribute use None value. To leave an attribute untouched just omit it. no cap, that's the whole trick 💅

Parameters:

name_or_id — name or ID of the port to update. (Required)
name — a symbolic name for the port. (Optional)
admin_state_up — the administrative status of the port, which is up (true) or down (false). (Optional)
fixed_ips —

list of ip_addresses and subnet_ids. (Optional) If you specify only a subnet ID, OpenStack Networking allocates an available IP from that subnet to the port. If you specify both a subnet ID and an IP address, OpenStack Networking tries to allocate the specified address to the port. For example:

[
    {
        "ip_address": "10.29.29.13",
        "subnet_id": "a78484c4-c380-4b47-85aa-21c51a2d8cbd",
    },
    ...,
]

security_groups — list of security group UUIDs. (Optional)
allowed_address_pairs —

allowed address pairs list. (Optional) For example:

[
    {
        "ip_address": "23.23.23.1",
        "mac_address": "fa:16:3e:c4:cd:3f",
    },
    ...,
]

extra_dhcp_opts —

extra DHCP options. (Optional). For example:

[{"opt_name": "opt name1", "opt_value": "value1"}, ...]

device_owner — the ID of the entity that uses this port. For example, a DHCP agent. (Optional)
device_id — the ID of the resource this port is attached to.
vnic_type (binding) — the type of the created port. (Optional)
port_security_enabled — the security port state created on the network. (Optional)
qos_policy_id — the ID of the QoS policy to apply for port.

Returns: the updated network Port object.

Raises: SDKException <#openstack.exceptions.SDKException> on operation error.

🌸 `update_project(name_or_id, enabled=None, domain_id=None, **kwargs)`

Update a project.

Parameters:

name_or_id — name or unique ID of the project.
enabled — whether the project is enabled or not.
domain_id — domain ID to scope the retrieved project.

Returns: an identity Project object.

👑 `update_qos_bandwidth_limit_rule(policy_name_or_id, rule_id, **kwargs)`

Update a QoS bandwidth limit rule.

Parameters:

policy_name_or_id (string) — name or ID of the QoS policy to which rule is associated.
rule_id (string) — ID of rule to update.
max_kbps (int) — maximum bandwidth limit value (in kilobits per second).
max_burst_kbps (int) — maximum burst value (in kilobits).
direction (string) — ingress or egress. The direction in which the traffic will be limited.

Returns: the updated network QoSBandwidthLimitRule object.

Raises: SDKException <#openstack.exceptions.SDKException> on operation error.

🧚 `update_qos_dscp_marking_rule(policy_name_or_id, rule_id, **kwargs)`

Update a QoS DSCP marking rule.

Parameters:

policy_name_or_id (string) — name or ID of the QoS policy to which rule is associated.
rule_id (string) — ID of rule to update.
dscp_mark (int) — DSCP mark value.

Returns: the updated network QoSDSCPMarkingRule object.

Raises: SDKException <#openstack.exceptions.SDKException> on operation error.

⭐ `update_qos_minimum_bandwidth_rule(policy_name_or_id, rule_id, **kwargs)`

Update a QoS minimum bandwidth rule.

Parameters:

policy_name_or_id (string) — name or ID of the QoS policy to which rule is associated.
rule_id (string) — ID of rule to update.
min_kbps (int) — minimum bandwidth value (in kilobits per second).
direction (string) — ingress or egress. The direction in which the traffic will be available.

Returns: the updated network QoSMinimumBandwidthRule object.

Raises: SDKException <#openstack.exceptions.SDKException> on operation error.

💜 `update_qos_policy(name_or_id, **kwargs)`

Update an existing QoS policy.

Parameters:

name_or_id (string) — name or ID of the QoS policy to update.
policy_name (string) — the new name of the QoS policy.
description (string) — the new description of the QoS policy.
shared (bool) — if True, the QoS policy will be set as shared.
default (bool) — if True, the QoS policy will be set as default for project.

Returns: the updated network QosPolicyRule object.

Raises: SDKException <#openstack.exceptions.SDKException> on operation error.

🌈 `update_recordset(zone, name_or_id, **kwargs)`

Update a recordset.

Parameters:

zone — name, ID or openstack.dns.v2.zone.Zone <#openstack.dns.v2.zone.Zone> instance of the zone managing the recordset.
name_or_id — name or ID of the recordset being updated.
records — list of the recordset definitions.
description — description of the recordset.
ttl — TTL (Time to live) value in seconds of the recordset.

Returns: a dict representing the updated recordset.

Raises: SDKException <#openstack.exceptions.SDKException> on operation error.

💖 `update_role(name_or_id, name, **kwargs)`

Update a Keystone role.

Parameters:

name_or_id — name or unique ID of the role.
name (string) — the new role name.
domain_id — domain id.

Returns: an identity Role object.

Raises: SDKException <#openstack.exceptions.SDKException> if the role cannot be created.

🔥 `update_router(name_or_id, name=None, admin_state_up=None, ext_gateway_net_id=None, enable_snat=None, ext_fixed_ips=None, routes=None)`

Update an existing logical router.

Parameters:

name_or_id (string) — the name or UUID of the router to update.
name (string) — the new router name.
admin_state_up (bool) — the administrative state of the router.
ext_gateway_net_id (string) — the network ID for the external gateway.
enable_snat (bool) — enable Source NAT (SNAT) attribute.
ext_fixed_ips —
routes (list) — a list of dicts with destination and nexthop keys. Wanna nuke all the routes? Pass an empty list ([]) and they're gone, periodt.

Example:

[{"destination": "179.24.1.0/24", "nexthop": "172.24.3.99"}]

Returns

The updated network Router object. 🛣️

Raises

SDKException <#openstack.exceptions.SDKException> on operation error. 😭

`update_security_group(name_or_id, **kwargs)`

Update a security group — glow-up time for your firewall vibes ✨

Parameters

name_or_id (string) — the name or ID of the security group you're updating.
name (string) — the new name for the security group.
description (string) — the new description for the security group.

Returns

A openstack.network.v2.security_group.SecurityGroup describing the updated security group. 🎀

Raises

SDKException <#openstack.exceptions.SDKException> on operation error.

`update_server(name_or_id, detailed=False, bare=False, **kwargs)`

Update a server. lowkey the main character of compute calls 👑

Parameters

name_or_id — name of the server to be updated.
detailed — whether or not to add detailed additional information. Defaults to False.
bare — whether to skip adding any additional info to the server record. Defaults to False, meaning the addresses dict will be populated as needed from neutron. Setting to True implies detailed = False.
name — new name for the server.
description — new description for the server.

Returns

The updated compute Server object.

Raises

SDKException <#openstack.exceptions.SDKException> on operation error.

`update_stack(name_or_id, template_file=None, template_url=None, template_object=None, files=None, rollback=True, tags=None, wait=False, timeout=3600, environment_files=None, **parameters)`

Update a stack. heat stack, but make it a remake 🔥

Parameters

name_or_id — name or ID of the stack to update.
template_file — path to the template.
template_url — URL of template.
template_object — URL to retrieve template object.
files — dict of additional file content to include.
rollback — enable rollback on update failure.
wait — whether to wait for the delete to finish.
timeout — stack update timeout in seconds.
environment_files — paths to environment files to apply.

Other arguments will be passed as stack parameters which will take precedence over any parameters specified in the environments.

Only one of template_file, template_url, template_object should be specified. Pick one, bestie, not all three 🙈

Returns

a dict containing the stack description.

Raises

SDKException <#openstack.exceptions.SDKException> if something goes wrong during the OpenStack API calls.

`update_subnet(name_or_id, subnet_name=None, enable_dhcp=None, gateway_ip=None, disable_gateway_ip=None, allocation_pools=None, dns_nameservers=None, host_routes=None)`

Update an existing subnet. network glow-up, subnet edition 💅

Parameters

name_or_id (string) — name or ID of the subnet to update.
subnet_name (string) — the new name of the subnet.
enable_dhcp (bool) — set to True if DHCP is enabled and False if disabled.
gateway_ip (string) — the gateway IP address. When you specify both allocation_pools and gateway_ip, you must ensure that the gateway IP does not overlap with the specified allocation pools. ⚠️
disable_gateway_ip (bool) — set to True if gateway IP address is disabled and False if enabled. It is not allowed with gateway_ip. Default is False.
allocation_pools — a list of dicts with the start and end addresses for the allocation pools. For example:

[{"start": "192.168.199.2", "end": "192.168.199.254"}]

dns_nameservers — a list of DNS name servers for the subnet. For example:

["8.8.8.7", "8.8.8.8"]

host_routes — a list of host route dicts for the subnet. For example:

[
    {"destination": "0.0.0.0/0", "nexthop": "123.456.78.9"},
    {"destination": "192.168.0.0/24", "nexthop": "192.168.0.1"},
]

Returns

The updated network Subnet object.

Raises

SDKException <#openstack.exceptions.SDKException> on operation error.

`update_volume(name_or_id, **kwargs)`

Update a volume. storage but make it fresh 🍓

Parameters

name_or_id — name or unique ID of the volume.
kwargs — volume attributes to be updated.

Returns

The updated volume Volume object.

`update_zone(name_or_id, **kwargs)`

Update a zone. DNS but make it cute 🌈

Parameters

name_or_id — name or ID of the zone being updated.
email — email of the zone owner (only applies if zone_type is primary)
description — description of the zone
ttl — TTL (Time to live) value in seconds
masters — master nameservers (only applies if zone_type is secondary)

Returns

a dict representing the updated zone.

Raises

SDKException <#openstack.exceptions.SDKException> on operation error.

`validate_machine(name_or_id, for_deploy=True)`

Validate parameters of the machine. vibe check, but for baremetal 🖥️

Parameters

name_or_id (string) — the Name or UUID value representing the baremetal node.
for_deploy (bool) — if True, validate readiness for deployment, otherwise validate only the power management properties.

Raises

ValidationException <#openstack.exceptions.ValidationException>

`volume_exists(name_or_id)`

Check if a volume exists. simple as that, bestie 🫶

Parameters

name_or_id — name or unique ID of the volume.

Returns

True if the volume exists, else False.

`wait_for_baremetal_node_lock(node, timeout=30)`

Wait for a baremetal node to have no lock.

DEPRECATED, use wait_for_node_reservation on the baremetal proxy. bestie pls stop using this one 😭

Raises

SDKException <#openstack.exceptions.SDKException> upon client failure.

Returns

None

`wait_for_server(server, auto_ip=True, ips=None, ip_pool=None, reuse=True, timeout=180, nat_destination=None)`

Wait for a server to reach ACTIVE status. the classic "is it up yet" but automated ⏳

Once you have a Connection instance, services are accessed through instances of Proxy <#openstack.proxy.Proxy> or subclasses of it that exist as attributes on the Connection <#openstack.connection.Connection>.

🌸 Service Proxies 🌸

The following service proxies exist on the Connection <#openstack.connection.Connection>. The service proxies are all always present on the Connection <#openstack.connection.Connection> object, but the combination of your CloudRegion and the catalog of the cloud in question control which services can be used. iykyk 💫

🚀 Accelerator API 🚀

The Accelerator Class

The accelerator high-level interface is available through the accelerator member of a Connection <#openstack.connection.Connection> object. The accelerator member will only be added if the service is detected. not me checking the catalog before sliding in 🙈

Deployable Operations

class openstack.accelerator.v2._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

`deployables(**query)`

Retrieve a generator of deployables. it's giving "here's everything, one at a time" ✨

Parameters

query — optional query parameters to be sent to restrict the deployables to be returned.

Returns — a generator of deployable instances, one per deployable, lazily handed to you like snacks passed down a row 🍓

`get_deployable(deployable, fields=None)`

Grab exactly one deployable. Just the one. No sharing 💅

Parameters

deployable — the value can be the ID of a deployable, or a Deployable instance (from openstack.accelerator.v2.deployable.Deployable), and it'll play nice either way (iykyk, you can just hand it the object)

Returns — one Deployable (openstack.accelerator.v2.deployable.Deployable)

Raises — NotFoundException (openstack.exceptions.NotFoundException) when no deployable matching the criteria could be found 😭 like, it looked, it's not there

`update_deployable(uuid, patch)`

Reconfig the FPGA with new bitstream. hardware glow-up arc ✨

Parameters

uuid — the value can be the UUID of a deployable
patch — the information to reconfig

Returns — the results of FPGA reconfig 🎀

🦋 Device Operations 🦋

class openstack.accelerator.v2._proxy.Proxy(session, *,
service_type=None, service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

okay that constructor signature is long long, but every single kwarg up there is real and named exactly like that, so don't come for me 💀

`devices(**query)`

Retrieve a generator of devices. all the devices, streamed to you ⭐

Parameters

query — optional query parameters you send along to restrict which devices come back. Available parameters include:
- hostname: the hostname of the device
- type: the type of the device
- vendor: the vendor ID of the device
- sort: a list of sorting keys separated by commas. Each sorting key can optionally be attached with a sorting direction modifier, which can be asc or desc
- limit: requests a specified size of returned items from the query — gives you a number of items up to the specified limit value
- marker: specifies the ID of the last-seen item. Use the limit parameter to make an initial limited request, then use the ID of the last-seen item from the response as the marker parameter value in a subsequent limited request

Returns — a generator of device instances 💖

`get_device(device, fields=None)`

Get a single device. one (1) device. that's it. main character energy 👑

Parameters

device — the value can be the ID of a device, or a Device instance (from openstack.accelerator.v2.device.Device)

Returns — one Device (openstack.accelerator.v2.device.Device)

Raises — NotFoundException (openstack.exceptions.NotFoundException) when no device matching the criteria could be found 🙈 gone, vanished, not in the vibes

🌈 Device Profile Operations 🌈

class openstack.accelerator.v2._proxy.Proxy(session, *,
service_type=None, service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

`device_profiles(**query)`

Retrieve a generator of device profiles. profiles, but for devices, keep up 🧚

Parameters

query — optional query parameters to be sent to restrict the device profiles to be returned

Returns — a generator of device profile instances ✨

`create_device_profile(**attrs)`

Create a device_profile. new profile just dropped 🔥

Parameters

attrs — a list of device_profiles

Returns — the list of created device profiles 💖

`delete_device_profile(device_profile, ignore_missing=True)`

Delete a device profile. bye bestie 💀

Parameters

device_profile — the value can be either the ID of a device profile, or a DeviceProfile instance (from openstack.accelerator.v2.device_profile.DeviceProfile)
ignore_missing — when set to False, NotFoundException (openstack.exceptions.NotFoundException) will be raised when the device profile does not exist. When set to True, no exception will be set when attempting to delete a nonexistent device profile (default is True, so it's forgiving by default — cute)

Returns — the deleted device profile 🎀

`get_device_profile(device_profile, fields=None)`

Get a single device profile. singular. one. ✨

Parameters

device_profile — the value can be the ID of a device profile, or a ~openstack.accelerator.v2.device_profile.DeviceProfile instance

Returns — one ~openstack.accelerator.v2.device_profile.DeviceProfile class instance

Raises — NotFoundException (openstack.exceptions.NotFoundException) when no device profile matching the criteria could be found 😭 nothing matched, it's giving empty results

👑 Accelerator Request Operations 👑

class openstack.accelerator.v2._proxy.Proxy(session, *,
service_type=None, service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

`accelerator_requests(**query)`

Retrieve a generator of accelerator requests. the ARQ pipeline is flowing 🌸

Parameters

query — optional query parameters to be sent to restrict the accelerator requests to be returned

Returns — a generator of accelerator request instances ⭐

`create_accelerator_request(**attrs)`

Create an ARQs for a single device profile. yes, "ARQs", plural, that's literally what the docs say, no I will not be fixing it 💅

Parameters

attrs — request body.

Returns — the created accelerator request instance 💜

`delete_accelerator_request(accelerator_request, ignore_missing=True)`

Delete an accelerator request. yeeting it into the void 🌈

Parameters

accelerator_request — the value can be either the ID of an accelerator request, or an AcceleratorRequest instance (from openstack.accelerator.v2.accelerator_request.AcceleratorRequest)
ignore_missing — when set to False, NotFoundException (openstack.exceptions.NotFoundException) will be raised when the accelerator request does not exist. When set to True, no exception will be set when attempting to delete a nonexistent accelerator request 🙈

Returns — None (nothing! empty! silence! that's the answer)

`get_accelerator_request(accelerator_request, fields=None)`

Get a single accelerator request. one lil request, hand-delivered 🫶

Parameters

accelerator_request — the value can be the ID of an accelerator request, or a ~openstack.accelerator.v2.accelerator_request.AcceleratorRequest instance

Returns — one ~openstack.accelerator.v2.accelerator_request.AcceleratorRequest class instance

Raises — NotFoundException (openstack.exceptions.NotFoundException) when no accelerator request matching the criteria could be found 😭

`update_accelerator_request(uuid, properties)`

Bind/Unbind an accelerator to VM. it's giving matchmaking, honestly 💖

Parameters

uuid — the uuid of the accelerator_request to be bound/unbound
properties — the info of VM that will bind/unbind the accelerator

Returns — True if bind/unbind succeeded, False otherwise (it literally just tells you yes or no, no drama, no exception, just a boolean bestie) ✅

💎 ATTRIBUTE OPERATIONS 💎

okay so first up, the proxy class — and yes, it's the same chonky signature as everywhere else in this API, no cap:

class openstack.accelerator.v2._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

`attributes(**query)`

Gives you a generator of attributes. 🎀

Parameters:

query — optional query parameters you can send along to restrict which attributes come back.

Returns: a generator of attribute instances. slay.

`create_attribute(**attrs)`

Makes a attribute. ✨

Parameters:

attrs — a list of attributes.

Returns: the list of created attributes.

`delete_attribute(attribute, ignore_missing=True)`

Deletes a attribute. 🗑️

Parameters:

attribute — the value can be either the ID of a attributes or a Attributes instance.
ignore_missing — when set to False, ResourceNotFound <#openstack.exceptions.ResourceNotFound> gets raised when the device profile does not exist. When set to True, no exception gets set when you attempt to delete a nonexistent device profile.

Returns: the deleted attribute.

`get_attribute(attribute, fields=None)`

Gets one single device profile. 🦋

Parameters:

attribute — the value can be the ID of a attribute or a ~openstack.accelerator.v2.attribute.Attribute instance.

Returns: one ~openstack.accelerator.v2.attribute.Attribute

Raises ResourceNotFound <#openstack.exceptions.ResourceNotFound> when no device profile matching the criteria could be found. 😭

🫶 HELPERS 🫶

Same proxy class, same exact signature, we're just in the helper zone now:

class openstack.accelerator.v2._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

`wait_for_status(res, status, failures=None, interval=2, wait=None, attribute='status', callback=None)`

Waits for the resource to hit a particular status. the way this one just sits there and vibes until things are ready ✨

Parameters:

session — the session to use for making this request.
resource — the resource to wait on to reach the status. The resource must have a status attribute specified via attribute.
status — the desired status of the resource.
failures — statuses that would indicate the transition failed, such as 'ERROR'. Defaults to ['ERROR'].
interval — number of seconds to wait between checks.
wait — maximum number of seconds to wait for the transition. Set to None to wait forever. 😭
attribute — name of the resource attribute that contains the status.
callback — a callback function. This gets called with a single value, progress. This is API specific but is generally a percentage value from 0-100.

Returns: the updated resource.

Raises ResourceTimeout <#openstack.exceptions.ResourceTimeout> if the transition to status failed to occur in wait seconds.

Raises ResourceFailure <#openstack.exceptions.ResourceFailure> if the resource transitioned to one of the states in failures.

Raises AttributeError if the resource does not have a status attribute. 💀

`wait_for_delete(res, interval=2, wait=120, callback=None)`

Waits for a resource to be deleted. bye bestie 👋

Parameters:

res — the resource to wait on to be deleted.
interval — number of seconds to wait before to consecutive checks.
wait — maximum number of seconds to wait before the change.
callback — a callback function. This gets called with a single value, progress, which is a percentage value from 0-100.

Returns: the resource is returned on success.

Raises ResourceTimeout <#openstack.exceptions.ResourceTimeout> if transition to delete failed to occur in the specified seconds.

🔥 BAREMETAL API 🔥

For details on how to use baremetal, see Using OpenStack Baremetal <>. iykyk 🫶

👑 THE BAREMETAL CLASS 👑

The baremetal high-level interface is available through the baremetal member of a Connection <#openstack.connection.Connection> object. The baremetal member only gets added if the service is detected. it's giving ✨conditional✨, and we respect that.

🌈 NODE OPERATIONS 🌈

class openstack.baremetal.v1._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

`nodes(details=False, **query)`

Gives you a generator of nodes. 💅

Parameters:

details — a boolean indicating whether the detailed information for every node should be returned.
query — optional query parameters to be sent to restrict the nodes returned. Available parameters include:
- associated: only return those which are, or are not, associated with an instance_id.
- conductor_group: only return those in the specified conductor_group.
- driver: only return those with the specified driver.
- fault: only return those with the specified fault type.
- fields: a list containing one or more fields to be returned in the response. This may lead to some performance gain because other fields of the resource are not refreshed.
- instance_id: only return the node with this specific instance UUID or an empty set if not found.
- is_maintenance: only return those with maintenance set to True or False.
- limit: requests at most the specified number of nodes be returned from the query.
- marker: specifies the ID of the last-seen node. Use the limit parameter to make an initial limited request and use the ID of the last-seen node from the response as the marker value in a subsequent limited request.
- provision_state: only return those nodes with the specified provision_state.
- resource_class: only return those with the specified resource_class.
- shard: only return nodes matching the supplied shard key.
- sort_dir: sorts the response by the requested sort direction. A valid value is asc (ascending) or desc (descending). Default is asc. You can specify multiple pairs of sort key and sort direction query parameters. If you omit the sort direction in a pair, the API uses the natural sorting direction of the server attribute that is provided as the sort_key.
- sort_key: sorts the response by the this attribute value. Default is id. You can specify multiple pairs of sort key and sort direction query parameters. If you omit the sort direction in a pair, the API uses the natural sorting direction of the server attribute that is provided as the sort_key.

Returns: a generator of Node <#openstack.baremetal.v1.node.Node> 🌸

`create_node(**attrs)`

Spinning up a brand-new node from attributes, bestie ✨

Peep create() for the tea on what the initial provision state actually is — that part's not re-explained here.

Parameters

attrs — keyword args that get used to create a Node.

Returns

The results of node creation. Yay, a node 🎀

`find_node(name_or_id, ignore_missing=True, *, details=True)`

Find one single node. Just the one. Not a crowd 🫶

Parameters

name_or_id — the name or ID of a node.
ignore_missing — when this is False, a NotFoundException gets raised if the node doesn't exist. When it's True, you just get None back when you try to find a nonexistent node. Chill.
details — a boolean saying whether the detailed info for the node should come back or not.

Returns

One Node object or None.

`get_node(node, fields=None)`

Grab one specific node 💅

Parameters

node — the value can be the name or ID of a node, or a Node instance.
fields — limit the resource fields to fetch.

Returns

One Node.

Raises NotFoundException when no node matching the name or ID could be found 😭

`update_node(node, retry_on_conflict=True, **attrs)`

Update a node, glow-up time ✨

Parameters

node — the name or ID of a node, or a Node instance.
retry_on_conflict — whether to retry an HTTP CONFLICT error. Most of the time it can be retried, since it's caused by the node being locked. But when setting instance_id, this is a normal code and should not be retried. iykyk.
attrs — the attributes to update on the node represented by the node parameter.

Returns

The updated node.

`patch_node(node, patch, reset_interfaces=None, retry_on_conflict=True)`

Apply a JSON patch straight to the node 🧚

Parameters

node — the name or ID of a node, or a Node instance.
patch — JSON patch to apply.
reset_interfaces — whether to reset the node hardware interfaces to their defaults. This only works when you're changing drivers. Added in API microversion 1.45.
retry_on_conflict — whether to retry an HTTP CONFLICT error. Most of the time it can be retried, since it's caused by the node being locked. However, when setting instance_id, this is a normal code and should not be retried.

See Update Node in the docs (https://docs.openstack.org/api-ref/baremetal/?expanded=update-node-detail#update-node) for the details.

Returns

The updated node.

`set_node_provision_state(node, target, config_drive=None, clean_steps=None, rescue_password=None, wait=False, timeout=None, deploy_steps=None)`

Run an action that modifies the node's provision state 🔥

Heads up: this call is asynchronous — it returns success as soon as the Bare Metal service acknowledges the request. So don't @ me if the state isn't already there.

Parameters

node — the name or ID of a node, or a Node instance.
target — the provisioning action, e.g. active, provide. Check the Bare Metal service docs for the full list of available actions.
config_drive — config drive to pass to the node, only valid for active and rebuild targets. You can use functions from openstack.baremetal.configdrive to build it.
clean_steps — clean steps to execute, only valid for the clean target.
rescue_password — password for the rescue operation, only valid for the rescue target.
wait — whether to wait for the node to get into the expected state. The expected state is figured out from a combo of the current provision state and target.
timeout — if wait is set to True, this specifies how much (in seconds) to wait for the expected state to be reached. The value of None (the default) means no client-side timeout.
deploy_steps — deploy steps to execute, only valid for active and rebuild targets.

Returns

The updated Node.

Raises ValueError if config_drive, clean_steps, deploy_steps or rescue_password are provided with an invalid target. Watch out 💀

`get_node_boot_device(node)`

Get the node's boot device 🌸

Parameters

node — the name or ID of a node, or a Node instance.

Returns

The node boot device.

`set_node_boot_device(node, boot_device, persistent=False)`

Set the node's boot device 💅

Parameters

node — the name or ID of a node, or a Node instance.
boot_device — boot device to assign to the node.
persistent — if the boot device change is maintained after node reboot.

Returns

The updated Node.

`get_node_supported_boot_devices(node)`

Get the supported boot devices for a node 🦋

Parameters

node — the name or ID of a node, or a Node instance.

Returns

The node boot device.

`set_node_boot_mode(node, target)`

Make a request to change the node's boot mode 👑

Parameters

node — the name or ID of a node, or a Node instance.
target — the boot mode to set for the node, one of either 'uefi'/'bios'.

`set_node_secure_boot(node, target)`

Make a request to change the node's secure boot state 🔐

Parameters

node — the name or ID of a node, or a Node instance.
target — a boolean indicating the secure boot state to set. True/False correspond to 'on'/'off' respectively.

`inject_nmi_to_node(node)`

Inject an NMI into the node 💀

It injects a non-maskable interrupt (NMI) message to the node. This is used when response time is critical — like during non-recoverable hardware errors. Also, virsh inject-nmi is useful for triggering a crashdump in Windows guests.

Parameters

node — the name or ID of a node, or a Node instance.

Returns

None.

`wait_for_nodes_provision_state(nodes, expected_state, timeout=None, abort_on_failed_state=True, fail=True)`

Wait for the nodes to reach the expected state ⏳ no rush… actually there is a rush

Parameters

nodes — list of nodes — name, ID or Node instance.
expected_state — the expected provisioning state to reach.
timeout — if wait is set to True, this specifies how much (in seconds) to wait for the expected state to be reached. The value of None (the default) means no client-side timeout.
abort_on_failed_state — if True (the default), it aborts waiting if any node reaches a failure state that doesn't match the expected one. Note that the failure state for the enroll -> manageable transition is enroll again 🙈
fail — if set to False, this call will not raise on timeouts and provisioning failures.

Returns — if fail is True (the default, bestie), you get the list of Node instances that actually made it to the state you asked for. If fail is False, you get a WaitResult named tuple instead. Two totally different shapes, so watch which one you're getting, iykyk 💅

Raises — ResourceFailure if a node lands in an error state and abort_on_failed_state is True. And ResourceTimeout on timeout. Like, it will simply give up on you 🫠

`set_node_power_state(node, target, wait=False, timeout=None)`

Run an action that modifies a node's power state. ⚡

Heads up: this call is asynchronous, so it returns success the second the Bare Metal service acknowledges the request — not when the machine is actually on/off. Don't @ me when the box isn't powered on yet 😭

Parameters
- node — the value can be the name or ID of a node, or a Node instance.
- target — the target power state, one of PowerAction or a string.
- wait — whether to wait for the node to get into the expected state.
- timeout — if wait is set to True, this says how much (in seconds) to wait for the expected state to be reached. The value None (the default) means no client-side timeout.

`wait_for_node_power_state(node, expected_state, timeout=None)`

Wait for the node to reach the power state. Just... sit there and vibe until the hardware agrees with you 🌸

Parameters
- node — the value can be the name or ID of a node, or a Node instance.
- timeout — how much (in seconds) to wait for the target state to be reached. The value None (the default) means no timeout.

Returns — the updated Node ✨

`wait_for_node_reservation(node, timeout=None)`

Wait for a lock on the node to be released. 🔒

Okay so context, because this one is lowkey a whole thing: bare metal nodes in ironic have a reservation lock, and that lock is how ironic says "a conductor has locked this node while performing some sort of action" — like changing configuration because of a machine state change.

This lock can show up during power syncronization, and it prevents updates to objects attached to the node, such as ports.

Ngl bestie, nothing actually stops a conductor from grabbing the lock again after this call returns, so treat this as best effort. It's giving "I tried my best" 💀

It returns immediately if there's no reservation on the node, so no awkward waiting around for nothing.

Parameters
- node — the value can be the name or ID of a node, or a Node instance.
- timeout — how much (in seconds) to wait for the lock to be released. The value None (the default) means no timeout.

Returns — the updated Node 🦋

`validate_node(node, required=('boot', 'deploy', 'power'))`

Validate required information on a node. It's the vibe check for your node, honestly 🔥

Parameters
- node — the value can be either the name or ID of a node, or a Node instance.
- required — list of interfaces that are required to pass validation. The default value is the list of minimum required interfaces for provisioning.

Returns — a dict mapping interface names to ValidationResult objects.

Raises — ValidationException if validation fails for a required interface. 😭

`set_node_maintenance(node, reason=None)`

Enable maintenance mode on the node. 🛠️

Parameters
- node — the value can be either the name or ID of a node, or a Node instance.
- reason — optional reason for maintenance.

Returns — this Node instance.

`unset_node_maintenance(node)`

Disable maintenance mode on the node. Back to business 💅

Parameters
- node — the value can be either the name or ID of a node, or a Node instance.

Returns — this Node instance.

`delete_node(node, ignore_missing=True)`

Delete a node. Poof, gone, bye 👋

Parameters
- node — the value can be either the name or ID of a node, or a Node instance.
- ignore_missing — when set to False, an exception NotFoundException will be raised when the node could not be found. When set to True, no exception will be raised when attempting to delete a non-existent node.

Returns — the instance of the node which was deleted.

`list_node_vendor_passthru(node)`

Lists vendor_passthru for a node. 🎀

Parameters
- node — the value can be the name or ID of a node, or a Node instance.

Returns — a list of vendor_passthru methods for the node.

`get_node_console(node)`

Get the console for a node. 🖥️

Parameters
- node — the value can be the name or ID of a node, or a Node instance.

Returns — connection information for the console.

`enable_node_console(node)`

Enable the console for a node. ✨

Parameters
- node — the value can be the name or ID of a node, or a Node instance.

Returns — None

`disable_node_console(node)`

Disable the console for a node. 🙈

Parameters
- node — the value can be the name or ID of a node, or a Node instance.

Returns — None

🎀 Node Trait Operations 🎀

Okay so this whole little section is the same proxy class, she just has a whole other group of methods living in her. Here's her full signature so you know exactly what she is, every last kwarg, no cap:

class openstack.baremetal.v1._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

`add_node_trait(node, trait)`

Add a trait to a node. 🍓

Parameters
- node — the value can be the name or ID of a node, or a Node instance.
- trait — trait to remove from the node.

Bestie I need you to know that the docs literally say "trait to remove" on the add method 😭 that's copy-paste energy at its finest — this method is the one that adds the trait, periodt.

Returns — the updated node

`remove_node_trait(node, trait, ignore_missing=True)`

Remove a trait from a node. 🧚

Parameters
- node — the value can be the name or ID of a node, or a Node instance.
- trait — trait to remove from the node.
- ignore_missing — when set to False, an exception NotFoundException will be raised when the trait could not be found. When set to True, no exception will be raised when attempting to delete a non-existent trait.

Returns — the updated Node

`set_node_traits(node, traits)`

Set traits for a node. 👑

Key detail: it removes any existing traits and then adds the traits you pass in to this method. So it's a full replace, not an append — your old traits are gone, gone, gone 💀

Parameters
- node — the value can be the name or ID of a node, or a Node instance.
- traits — list of traits to add to the node.

Returns — the updated Node 🌈

🦋 Port Operations 🦋

Okay bestie, this is where we mess with ports — the actual network hookups for your baremetal nodes. First, the vibe check that is the constructor signature (yes it's long, yes it's iconic, no we are not skipping a single kwarg 💅):

class openstack.baremetal.v1._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

`ports(details=False, **query)` ✨

Retrieve a generator of ports. A generator, bestie — it's giving "lazy but efficient" main character energy 🧚

Parameters

details — A boolean indicating whether the detailed information for every port should be returned.
query —

Optional query parameters to be sent to restrict the ports returned. Available parameters include:

address: Only return ports with the specified physical hardware address, typically a MAC address.
conductor_groups: Only return ports associated with nodes in the specified conductor group(s).
driver: Only return those with the specified driver.
fields: A list containing one or more fields to be returned in the response. This may lead to some performance gain because other fields of the resource are not refreshed.
limit: Requests at most the specified number of ports be returned from the query.
marker: Specifies the ID of the last-seen port. Use the limit parameter to make an initial limited request and use the ID of the last-seen port from the response as the marker value in a subsequent limited request.
node: only return the ones associated with this specific node (name or UUID), or an empty set if not found.
node_id: only return the ones associated with this specific node UUID, or an empty set if not found.
portgroup: only return the ports associated with this specific Portgroup (name or UUID), or an empty set if not found. Added in API microversion 1.24.
sort_dir: Sorts the response by the requested sort direction. A valid value is asc (ascending) or desc (descending). Default is asc. You can specify multiple pairs of sort key and sort direction query parameters. If you omit the sort direction in a pair, the API uses the natural sorting direction of the server attribute that is provided as the sort_key.
sort_key: Sorts the response by the this attribute value. Default is id. You can specify multiple pairs of sort key and sort direction query parameters. If you omit the sort direction in a pair, the API uses the natural sorting direction of the server attribute that is provided as the sort_key.

Returns

A generator of port instances. 🌸

`create_port(**attrs)` 💖

Create a new port from attributes. Baby's first port, slay.

Parameters

attrs — Keyword arguments that will be used to create a Port <#openstack.baremetal.v1.port.Port>.

Returns

The results of port creation. 🎀

`find_port(name_or_id, ignore_missing=True, *, details=True)` 🔍

Find a single port. Just the one. The main character port, iykyk.

Parameters

name_or_id — The ID of a port.
ignore_missing — When set to False, an exception of NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the port does not exist. When set to True, None will be returned when attempting to find a nonexistent port.
details — A boolean indicating whether the detailed information for every port should be returned.

Returns

One Port <#openstack.baremetal.v1.port.Port> object or None.

`get_port(port, fields=None)` ⭐

Get a specific port. Vibes: direct, no games.

Parameters

port — The value can be the ID of a port or a Port <#openstack.baremetal.v1.port.Port> instance.
fields — Limit the resource fields to fetch.

Returns

One Port <#openstack.baremetal.v1.port.Port>

Raises NotFoundException <#openstack.exceptions.NotFoundException> when no port matching the name or ID could be found.

Fr fr, if it's not there, it throws. No silent ghosting 🙈

`update_port(port, **attrs)` 💅

Update a port. Glow-up time.

Parameters

port — Either the ID of a port or an instance of Port <#openstack.baremetal.v1.port.Port>.
attrs — The attributes to update on the port represented by the port parameter.

Returns

The updated port. ✨

`patch_port(port, patch)` 🩹

Apply a JSON patch to the port. Surgical, precise, lowkey iconic.

Parameters

port — The value can be the ID of a port or a Port <#openstack.baremetal.v1.port.Port> instance.
patch — JSON patch to apply.

Returns

The updated port.

`delete_port(port, ignore_missing=True)` 💀

Delete a port. Gone. Reduced to atoms. Periodt.

Parameters

port — The value can be either the ID of a port or a Port <#openstack.baremetal.v1.port.Port> instance.
ignore_missing — When set to False, an exception NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the port could not be found. When set to True, no exception will be raised when attempting to delete a non-existent port.

Returns

The instance of the port which was deleted. 🫶

🎀 Port Group Operations 🎀

Port groups, for when one port just isn't enough and you need to be extra. Same signature as above, because consistency is the moment:

class openstack.baremetal.v1._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

`port_groups(details=False, **query)` 🌈

Retrieve a generator of port groups.

Parameters

details — A boolean indicating whether the detailed information for every port group should be returned.
query —

Optional query parameters to be sent to restrict the port groups returned. Available parameters include:

address: Only return portgroups with the specified physical hardware address, typically a MAC address.
fields: A list containing one or more fields to be returned in the response. This may lead to some performance gain because other fields of the resource are not refreshed.
limit: Requests at most the specified number of portgroups returned from the query.
marker: Specifies the ID of the last-seen portgroup. Use the limit parameter to make an initial limited request and use the ID of the last-seen portgroup from the response as the marker value in a subsequent limited request.
node: only return the ones associated with this specific node (name or UUID), or an empty set if not found.
sort_dir: Sorts the response by the requested sort direction. A valid value is asc (ascending) or desc (descending). Default is asc. You can specify multiple pairs of sort key and sort direction query parameters. If you omit the sort direction in a pair, the API uses the natural sorting direction of the server attribute that is provided as the sort_key.

sort_key — sorts the response by this attribute's value (default is id, bestie). And yes, you can stack multiple pairs of sort key + sort direction query params. If you leave the sort direction out of a pair, the API just uses the natural sorting direction of the server attribute you handed it as the sort_key. Slay, it's flexible. ✨

Returns — a generator of port group instances. 🎀

`create_port_group(**attrs)`

Makes a brand-new portgroup out of attributes. Iconic behavior.

Parameters

attrs — keyword arguments that get used to create a PortGroup <#openstack.baremetal.v1.port_group.PortGroup>.

Returns — the results of portgroup creation. 💅

`find_port_group(name_or_id, ignore_missing=True, *, details=True)`

Finds you one single port group. One. Not a list. 🫶

Parameters

name_or_id — the name or ID of a portgroup.
ignore_missing — when it's set to False, an exception of NotFoundException <#openstack.exceptions.NotFoundException> gets raised if the port group doesn't exist. When it's True, None comes back instead when you go looking for a port group that isn't there. 🙈
details — a boolean saying whether the detailed info for the port group should be returned.

Returns — one PortGroup <#openstack.baremetal.v1.port_group.PortGroup> object, or None. 💖

`get_port_group(port_group, fields=None)`

Gets you a specific port group, no cap.

Parameters

port_group — the value can be the name or ID of a chassis or a PortGroup <#openstack.baremetal.v1.port_group.PortGroup> instance. (Yes bestie, the docs really say chassis here — I'm just telling you what it says. 😭)
fields — limits the resource fields to fetch.

Returns — one PortGroup <#openstack.baremetal.v1.port_group.PortGroup>.

Raises NotFoundException <#openstack.exceptions.NotFoundException> when no port group matching the name or ID could be found. 💀

`update_port_group(port_group, **attrs)`

Updates a port group. Glow-up time. 🔥

Parameters

port_group — either the name or the ID of a port group, or an instance of PortGroup <#openstack.baremetal.v1.port_group.PortGroup>.
attrs — the attributes to update on the port group represented by the port_group parameter.

Returns — the updated port group. ✨

`patch_port_group(port_group, patch)`

Applies a JSON patch to the port_group. Surgery, but make it JSON. 🩹

Parameters

port_group — the value can be the ID of a port group or a PortGroup <#openstack.baremetal.v1.port_group.PortGroup> instance.
patch — the JSON patch to apply.

Returns — the updated port group. 💜

`delete_port_group(port_group, ignore_missing=True)`

Deletes a port group. Gone. Poof. 🦋

Parameters

port_group — the value can be either the name or ID of a port group or a PortGroup <#openstack.baremetal.v1.port_group.PortGroup> instance.
ignore_missing — when set to False, an exception NotFoundException <#openstack.exceptions.NotFoundException> gets raised when the port group couldn't be found. When set to True, no exception gets raised when you try to delete a port group that doesn't even exist. 🙈

Returns — the instance of the port group which was deleted. 💖

🚗 Driver Operations

class openstack.baremetal.v1._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

That's the whole constructor signature, every single kwarg, and yes you're gonna read all of them because I said so. 👑

`drivers(details=False, **query)`

Pulls a generator of drivers. 🌈

Parameters

details — a boolean saying whether the detailed info for every driver should be returned.
query — optional query parameters sent along to limit the resources being returned.

Returns — a generator of driver instances. ⭐

`get_driver(driver)`

Gets one specific driver. Main character energy. 👑

Parameters

driver — the value can be the name of a driver or a Driver <#openstack.baremetal.v1.driver.Driver> instance.

Returns — one Driver <#openstack.baremetal.v1.driver.Driver>.

Raises NotFoundException <#openstack.exceptions.NotFoundException> when no driver matching the name could be found. 😭

🏠 Chassis Operations

class openstack.baremetal.v1._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

Same constructor, same forty-something kwargs, we're doing this again bestie. 💀

`chassis(details=False, **query)`

Grabs a generator of chassis. Bestie, it's giving inventory. 🎀

Parameters

details — a boolean saying whether the detailed info for every chassis should be returned.
query — optional query parameters sent along to restrict which chassis get returned. The available parameters include:
- fields: a list holding one or more fields to be returned in the response. This may lead to some performance gain, because the other fields of the resource don't get refreshed. ⚡
- limit: requests at most the specified number of items come back from the query.
- marker: specifies the ID of the last-seen chassis. Use the limit parameter to make an initial limited request, then use the ID of the last-seen chassis from the response as the marker value in a subsequent limited request. 🔁
- sort_dir: sorts the response by the requested sort direction. A valid value is asc (ascending) or desc (descending). Default is asc. You can specify multiple pairs of sort key and sort direction query parameters. If you omit the sort direction in a pair, the API uses the natural sorting direction of the server attribute that's provided as the sort_key.
- sort_key: sorts the response by this attribute's value. Default is id. You can specify multiple pairs of sort key and sort direction query parameters. If you omit the sort direction in a pair, the API uses the natural sorting direction of the server attribute that's provided as the sort_key. ✨

Returns — a generator of chassis instances. 💖

`create_chassis(**attrs)`

Creates a new chassis from attributes. Fresh out the box. 🍓

Parameters

attrs — keyword arguments that'll be used to create a Chassis <#openstack.baremetal.v1.chassis.Chassis>.

Returns — the results of chassis creation. 💅

`find_chassis(name_or_id, ignore_missing=True, *, details=True)`

Finds a single chassis. Just the one, bestie. 🫶

Parameters

name_or_id — the ID of a chassis.
ignore_missing — when set to False, an exception of NotFoundException <#openstack.exceptions.NotFoundException> gets raised when the chassis doesn't exist. When set to True, None comes back when you try to find a chassis that isn't there. 🙈
details — a boolean saying whether the detailed info for the chassis should be returned.

Returns — one Chassis <#openstack.baremetal.v1.chassis.Chassis> object, or None. 💜

`get_chassis(chassis, fields=None)`

Gets you one specific chassis.

Parameters

chassis — the ID of a chassis, or a whole Chassis instance if you're feeling fancy ✨
- fields — limits which resource fields actually get fetched, so you're not hauling the entire thing over the wire 💅

Returns — one Chassis, that's it, that's the tea 🎀

Raises NotFoundException when literally no chassis matches that name or ID — like, it looked, it did not find, it's giving ghosted 😭

update_chassis(chassis, **attrs) — update a chassis, glow-up edition 💖

Parameters

chassis — either the ID of a chassis, or an actual Chassis instance, either works bestie
attrs — the attributes you want to update on the chassis that chassis is pointing at

Returns — the updated chassis, freshly slayed ✨

patch_chassis(chassis, patch) — apply a JSON patch to the chassis, surgical precision vibes 🔥

Parameters

chassis — the ID of a chassis or a Chassis instance, dealer's choice
patch — the JSON patch to apply

Returns — the updated chassis 👑

delete_chassis(chassis, ignore_missing=True) — yeet the chassis 🗑️

Parameters

chassis — either the ID of a chassis or a Chassis instance
ignore_missing — set it to False and a NotFoundException gets raised when the chassis can't be found. Leave it at True and no exception happens when you try to delete a chassis that doesn't exist. Like, nothing to delete, nothing to be dramatic about 💀

Returns — the instance of the chassis you just deleted

🌈 Virtual Media Operations 🌈

Still the same proxy class, no cap — here's the whole signature again so you never have to scroll up and lose your place, you're welcome 🫶

class openstack.baremetal.v1._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

attach_vmedia_to_node(node, device_type, image_url, image_download_source=None, retry_on_conflict=True) — attach a virtual media device to a node 🦋

Parameters

node — either the name or the ID of a node, or a Node instance. Any of the three, we're flexible 💅
device_type — the type of virtual media device
image_url — the URL of the image you're attaching
image_download_source — where the image download is coming from
retry_on_conflict — whether to retry HTTP CONFLICT errors. Ngl this can happen when the virtual media is already in use on a node or when the node is locked 🔒 and since the locked thing happens way more often, the default is True. Trust the defaults bestie.

Returns — None. Yeah, nothing. It's giving mysterious ✨

Raises NotSupported if the server doesn't support the VMEDIA API — rude of it, honestly 😤

detach_vmedia_from_node(node, device_types=None) — detach virtual media from the node, let it go 🕊️

Parameters

node — name or ID of a node, or a Node instance
device_types — a list with the types of virtual media devices you wanna detach

Returns — True if the virtual media got detached, otherwise False 🌸

Raises NotSupported if the server doesn't support the VMEDIA API

💜 VIF Operations 💜

Yup, the same proxy constructor, one more time — iconic of it to keep showing up 💅

class openstack.baremetal.v1._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

attach_vif_to_node(node, vif_id, retry_on_conflict=True, *, port=None, port_group=None) — attach a VIF to the node 🔌

Okay so lowkey the exact form of the VIF ID depends on the network interface the node is using. In the most common case it's a Network service port ID — and that is NOT a Bare Metal port ID, do not mix those up bestie 😭. Also a VIF can only be attached to one node at a time. One. Singular. Periodt.

Parameters

node — name or ID of a node, or a Node instance
vif_id — backend-specific VIF ID
retry_on_conflict — whether to retry HTTP CONFLICT errors. Happens when the VIF is already used on a node or when the node is locked, and since locked is the more common one, default is True 🔒
port — a UUID or Port instance of the port to attach the VIF to. You can only provide one of port or port_group 🎀
port_group — a UUID or PortGroup instance of the portgroup to attach the VIF to. Again — only one of port_group or port, pick a lane 💅

Returns — None, the void, the vibes ✨

Raises NotSupported if the server doesn't support the VIF API

Raises InvalidRequest if both port_id and port_group_id are provided — like we said, pick ONE 😤

detach_vif_from_node(node, vif_id, ignore_missing=True) — detach a VIF from the node 🫶

Same deal with the VIF ID: exact form depends on the network interface the node uses, and in the most common case it's a Network service port ID (NOT a Bare Metal port ID) 🦋

Parameters

node — name or ID of a node, or a Node instance
vif_id — backend-specific VIF ID
ignore_missing — set to False and NotFoundException gets raised when the VIF doesn't exist. Otherwise False is returned instead. Very chill of it 🌸

Returns — True if the VIF was detached, otherwise False

Raises NotSupported if the server doesn't support the VIF API

list_node_vifs(node) — list the IDs of VIFs attached to the node 📋

(Yes, the VIF ID form depends on the network interface the node uses, and yep, in the most common case it's a Network service port ID and NOT a Bare Metal port ID. Repetition is how you remember it bestie 💖)

Parameters

node — name or ID of a node, or a Node instance

Returns — a list of VIF IDs as strings ⭐

Raises NotSupported if the server doesn't support the VIF API

👑 Allocation Operations 👑

And the proxy signature AGAIN. At this point it's a main character, honestly 💅

class openstack.baremetal.v1._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

allocations(**query) — grab a generator of allocations, go off 🔥

Parameters

query — optional query parameters to send along so you can restrict which allocations come back. The available ones include:
- fields: a list containing one or more fields to be returned in the response. This can give you a lil performance boost because the other fields of the resource don't get refreshed 🚀
limit — asks the API for at most this many items back from the query. Cute little cap, use it. 💅
- marker — the ID of the last-seen allocation. The move here is: do one limited request with limit, then take the ID of the last-seen allocation from that response and shove it in as the marker value of your next limited request. Paging, but make it fashion. ✨
- sort_dir — sorts the response in whatever direction you asked for. Valid values are asc (ascending) or desc (descending), and the default is asc. You can pass multiple pairs of sort key + sort direction query parameters. If you skip the sort direction in a pair, the API just uses the natural sorting direction of the server attribute you gave as the sort_key. Slay.
- sort_key — sorts the response by this attribute's value. Default is id. Same deal: multiple pairs of sort key + sort direction are allowed, and if you leave out the sort direction in a pair, the API falls back to the natural sorting direction of that sort_key attribute. Periodt.

Returns

A generator of allocation instances. 🎁

`create_allocation(**attrs)`

Makes a brand-new allocation out of attributes. Iconic behaviour.

Parameters

attrs — keyword arguments that get used to create a Allocation <#openstack.baremetal.v1.allocation.Allocation>.

Returns The results of allocation creation. 🌱

`get_allocation(allocation, fields=None)`

Grabs one specific allocation, bestie. Just the one.

Parameters

allocation — the value can be the name or ID of an allocation, or a Allocation <#openstack.baremetal.v1.allocation.Allocation> instance.
fields — limits which resource fields get fetched.

Returns One Allocation <#openstack.baremetal.v1.allocation.Allocation>.

Raises NotFoundException <#openstack.exceptions.NotFoundException> when no allocation matching the name or ID could be found. 😭

`update_allocation(allocation, **attrs)`

Updates an allocation. Glow-up time. 💖

Parameters

allocation — the value can be the name or ID of an allocation, or a Allocation <#openstack.baremetal.v1.allocation.Allocation> instance.
attrs — the attributes to update on the allocation represented by the allocation parameter.

Returns The updated allocation. ✨

`patch_allocation(allocation, patch)`

Applies a JSON patch to the allocation. Surgical. Unbothered. 💅

Parameters

allocation — the value can be the name or ID of an allocation, or a Allocation <#openstack.baremetal.v1.allocation.Allocation> instance.
patch — JSON patch to apply.

Returns The updated allocation.

`delete_allocation(allocation, ignore_missing=True)`

Deletes an allocation. Bye bye 👋

Parameters

allocation — the value can be the name or ID of an allocation, or a Allocation <#openstack.baremetal.v1.allocation.Allocation> instance.
ignore_missing — when set to False, an exception NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the allocation could not be found. When set to True, no exception will be raised when attempting to delete a non-existent allocation.

Returns The instance of the allocation which was deleted. 🫶

`wait_for_allocation(allocation, timeout=None, ignore_error=False)`

Waits for the allocation to become active. The "are we there yet" of methods. 😭

Parameters

allocation — the value can be the name or ID of an allocation, or a Allocation <#openstack.baremetal.v1.allocation.Allocation> instance.
timeout — how much (in seconds) to wait for the allocation. The value of None (the default) means no client-side timeout.
ignore_error — if True, this call will raise an exception if the allocation reaches the error state. Otherwise the error state is considered successful and the call returns.

Returns The instance of the allocation.

Raises ResourceFailure <#openstack.exceptions.ResourceFailure> if allocation fails and ignore_error is False.

Raises ResourceTimeout <#openstack.exceptions.ResourceTimeout> on timeout. ⏰

🎀 Volume Connector Operations 🎀

class openstack.baremetal.v1._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

Yes that's the whole signature. No we're not shortening it. She contains multitudes. 🦋

`volume_connectors(details=False, **query)`

Retrieves a generator of volume_connector. Generator girlies rise ✨

Parameters

details — a boolean indicating whether the detailed information for every volume_connector should be returned.
query —

Optional query parameters to be sent to restrict the volume_connectors returned. Available parameters include:

fields: a list containing one or more fields to be returned in the response. This may lead to some performance gain because other fields of the resource are not refreshed. Speed. 🏎️
limit: requests at most the specified number of volume_connector be returned from the query.
marker: specifies the ID of the last-seen volume_connector. Use the limit parameter to make an initial limited request and use the ID of the last-seen volume_connector from the response as the marker value in subsequent limited request.
node: only return the ones associated with this specific node (name or UUID), or an empty set if not found.
sort_dir: sorts the response by the requested sort direction. A valid value is asc (ascending) or desc (descending). Default is asc. You can specify multiple pairs of sort key and sort direction query parameters. If you omit the sort direction in a pair, the API uses the natural sorting direction of the server attribute that is provided as the sort_key.
sort_key: sorts the response by the this attribute value. Default is id. You can specify multiple pairs of sort key and sort direction query parameters. If you omit the sort direction in a pair, the API uses the natural sorting direction of the server attribute that is provided as the sort_key.

Returns A generator of volume_connector instances. 🎁

`create_volume_connector(**attrs)`

Creates a new volume_connector from attributes. Fresh out the box, no cap.

Parameters attrs — keyword arguments that will be used to create a VolumeConnector <#openstack.baremetal.v1.volume_connector.VolumeConnector>.

Returns The results of volume_connector creation. 🌱

`find_volume_connector(vc_id, ignore_missing=True, *, details=True)`

Finds one single volume connector. Detective mode 🔍

Parameters

vc_id — the ID of a volume connector.
ignore_missing — when set to False, an exception of NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the volume connector does not exist. When set to True, None will be returned when attempting to find a nonexistent volume connector.
details — a boolean indicating whether the detailed information for the volume connector should be returned.

Returns One VolumeConnector object or None. 🙈

`get_volume_connector(volume_connector, fields=None)`

Gets a specific volume_connector.

Parameters

volume_connector — bestie you can hand it either the ID of a volume_connector or an actual VolumeConnector instance, whichever is closer 💅
- fields — limit the resource fields to fetch, so it's giving less is more ✨

Returns — one single VolumeConnector object, cute and complete 🎀

Raises — NotFoundException when no volume_connector matching the name or ID could be found 😭 like, it looked everywhere and found nothing.

`update_volume_connector(volume_connector, **attrs)`

Update a volume_connector, glow-up edition 🦋

Parameters

volume_connector — either the ID of a volume_connector or an instance of VolumeConnector 💖
attrs — the attributes to update on the volume_connector represented by the volume_connector parameter. yes, it says volume_connector twice, iykyk 🌸

Returns — the updated volume_connector, freshly slayed ✨

`patch_volume_connector(volume_connector, patch)`

Apply a JSON patch to the volume_connector — like a targeted edit, not a whole rewrite 🔥

Parameters

volume_connector — the value can be the ID of a volume_connector or a VolumeConnector instance 💜
patch — JSON patch to apply 🩹

Returns — the updated volume_connector.

`delete_volume_connector(volume_connector, ignore_missing=True)`

Delete an volume_connector — yeet it, respectfully 💀

Parameters

volume_connector — the value can be either the ID of a volume connector or a VolumeConnector instance 👑
ignore_missing — when set to False, an exception NotFoundException will be raised when the volume_connector could not be found. When set to True, no exception will be raised when attempting to delete a non-existent volume_connector — it just shrugs and moves on 🙈

Returns — the instance of the volume_connector which was deleted.

⚡ Volume Target Operations ⚡

Okay so this is the same proxy class energy, just scoped to volume targets. Here's the whole signature, no cap:

class openstack.baremetal.v1._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

`volume_targets(details=False, **query)`

Retrieve a generator of volume_target — a generator, bestie, so it's lazy and iconic 💅

Parameters

details — a boolean indicating whether the detailed information for every volume_target should be returned 🔍
query — optional query parameters to be sent to restrict the volume_targets returned. Available parameters include:
- fields: a list containing one or more fields to be returned in the response. This may lead to some performance gain because other fields of the resource are not refreshed. faster = slay ⚡
- limit: requests at most the specified number of volume_connector be returned from the query. (yes it literally says volume_connector here, I'm just the messenger 🫶)
- marker: specifies the ID of the last-seen volume_target. Use the limit parameter to make an initial limited request and use the ID of the last-seen volume_target from the response as the marker value in subsequent limited request. pagination core 🎀
- node: only return the ones associated with this specific node (name or UUID), or an empty set if not found.
- sort_dir: sorts the response by the requested sort direction. A valid value is asc (ascending) or desc (descending). Default is asc. You can specify multiple pairs of sort key and sort direction query parameters. If you omit the sort direction in a pair, the API uses the natural sorting direction of the server attribute that is provided as the sort_key.
- sort_key: sorts the response by the this attribute value. Default is id. You can specify multiple pairs of sort key and sort direction query parameters. If you omit the sort direction in a pair, the API uses the natural sorting direction of the server attribute that is provided as the sort_key.

Returns — a generator of volume_target instances 🌈

`create_volume_target(**attrs)`

Create a new volume_target from attributes — build it from scratch, main character energy 👑

Parameters

attrs — keyword arguments that will be used to create a VolumeTarget ✨

Returns — the results of volume_target creation 💖

`find_volume_target(vt_id, ignore_missing=True, *, details=True)`

Find a single volume target 🔎

Parameters

vt_id — the ID of a volume target.
ignore_missing — when set to False, an exception of NotFoundException will be raised when the volume connector does not exist. When set to True, None will be returned when attempting to find a nonexistent volume target. soft launch of a failure, honestly 🙈
details — a boolean indicating whether the detailed information for the volume target should be returned.

Returns — one VolumeTarget object or None.

`get_volume_target(volume_target, fields=None)`

Get a specific volume_target — just the one, focused, unbothered 🦋

Parameters

volume_target — the value can be the ID of a volume_target or a VolumeTarget instance 💜
fields — limit the resource fields to fetch.

Returns — one VolumeTarget ✨

Raises — NotFoundException when no volume_target matching the name or ID could be found 😭

`update_volume_target(volume_target, **attrs)`

Update a volume_target 💅

Parameters

volume_target — either the ID of a volume_target or an instance of VolumeTarget 🎀
attrs — the attributes to update on the volume_target represented by the volume_target parameter.

Returns — the updated volume_target.

`patch_volume_target(volume_target, patch)`

Apply a JSON patch to the volume_target — surgical, precise, iconic 🔥

Parameters

volume_target — the value can be the ID of a volume_target or a VolumeTarget instance 👑
patch — JSON patch to apply.

Returns — the updated volume_target.

`delete_volume_target(volume_target, ignore_missing=True)`

Delete an volume_target — gone, bye, no notes 💀

Parameters

volume_target — the value can be either the ID of a volume target or a VolumeTarget instance 🌸
ignore_missing — when set to False, an exception NotFoundException will be raised when the volume_target could not be found. When set to True, no exception will be raised when attempting to delete a non-existent volume_target. so forgiving fr fr 🫶

Returns — the instance of the volume_target which was deleted.

🌸 Deploy Template Operations 🌸

okay so first up, the deploy template squad 💅 here's the constructor you get for all of these:

class openstack.baremetal.v1._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

deploy_templates(details=False, **query) — Retrieve a generator of deploy_templates. bestie it's a generator, not a list, so don't be weird about it ✨
- details — A boolean indicating whether the detailed information for every deploy_templates should be returned.
- query — Optional query parameters to be sent to restrict the deploy_templates to be returned.
- Returns — A generator of Deploy templates instances.
create_deploy_template(**attrs) — Create a new deploy_template from attributes.
- attrs — Keyword arguments that will be used to create a DeployTemplate <#openstack.baremetal.v1.deploy_templates.DeployTemplate>.
- Returns — The results of deploy_template creation.
update_deploy_template(deploy_template, **attrs) — Update a deploy_template. glow-up time 🦋
- deploy_template — Either the ID of a deploy_template, or an instance of DeployTemplate <#openstack.baremetal.v1.deploy_templates.DeployTemplate>.
- attrs — The attributes to update on the deploy_template represented by the deploy_template parameter.
- Returns — The updated deploy_template.
delete_deploy_template(deploy_template, ignore_missing=True) — Delete a deploy_template. bye bestie 👋
- deploy_template — The value can be either the ID of a deploy_template or a DeployTemplate <#openstack.baremetal.v1.deploy_templates.DeployTemplate> instance.
- ignore_missing — When set to False, an exception:class:~openstack.exceptions.NotFoundException will be raised when the deploy_template could not be found. When set to True, no exception will be raised when attempting to delete a non-existent deploy_template.
- Returns — The instance of the deploy_template which was deleted.
get_deploy_template(deploy_template, fields=None) — Get a specific deployment template.
- deploy_template — The value can be the name or ID of a deployment template DeployTemplate <#openstack.baremetal.v1.deploy_templates.DeployTemplate> instance.
- fields — Limit the resource fields to fetch.
- Returns — One DeployTemplate <#openstack.baremetal.v1.deploy_templates.DeployTemplate>
- Raises — NotFoundException <#openstack.exceptions.NotFoundException> when no deployment template matching the name or ID could be found. 😭
patch_deploy_template(deploy_template, patch) — Apply a JSON patch to the deploy_templates.
- deploy_templates — The value can be the ID of a deploy_template or a DeployTemplate <#openstack.baremetal.v1.deploy_templates.DeployTemplate> instance. (yep, the docs say deploy_templates in the bullet and deploy_template in the signature — that's literally what's written, iykyk 🙈)
- patch — JSON patch to apply.
- Returns — The updated deploy_template.

🎀 Runbook Operations 🎀

same constructor energy, new resource. runbooks, let's go 🔥

class openstack.baremetal.v1._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

runbooks(details=False, **query) — Retrieve a generator of runbooks. again: generator ✨
- details — A boolean indicating whether the detailed information for every runbook should be returned.
- query — Optional query parameters to be sent to restrict the runbooks to be returned.
- Returns — A generator of Runbooks instances.
create_runbook(**attrs) — Create a new runbook from attributes.
- attrs — Keyword arguments that will be used to create a Runbook <#openstack.baremetal.v1.runbooks.Runbook>.
- Returns — The results of runbook creation.
update_runbook(runbook, **attrs) — Update a runbook.
- runbook — Either the ID of a runbook, or an instance of Runbook <#openstack.baremetal.v1.runbooks.Runbook>.
- attrs — The attributes to update on the runbook represented by the runbook parameter.
- Returns — The updated runbook.
delete_runbook(runbook, ignore_missing=True) — Delete a runbook. 💀
- runbook — The value can be either the ID of a runbook or a Runbook <#openstack.baremetal.v1.runbooks.Runbook> instance.
- ignore_missing — When set to False, an exception:class:~openstack.exceptions.NotFoundException will be raised when the runbook could not be found. When set to True, no exception will be raised when attempting to delete a non-existent runbook.
- Returns — The instance of the runbook which was deleted.
get_runbook(runbook, fields=None) — Get a specific runbook.
- runbook — The value can be the name or ID of a runbook Runbook <#openstack.baremetal.v1.runbooks.Runbook> instance.
- fields — Limit the resource fields to fetch.
- Returns — One Runbook <#openstack.baremetal.v1.runbooks.Runbook>
- Raises — NotFoundException <#openstack.exceptions.NotFoundException> when no runbook matching the name or ID could be found.
patch_runbook(runbook, patch) — Apply a JSON patch to the runbook.
- runbooks — The value can be the ID of a runbook or a Runbook <#openstack.baremetal.v1.runbooks.Runbook> instance. (plural in the docs again, no cap — copying faithfully 🫶)
- patch — JSON patch to apply.
- Returns — The updated runbook.

🧚 Runbook Trait Operations 🧚

traits!! the accessory layer of your runbook, lowkey obsessed 🌈

class openstack.baremetal.v1._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

add_runbook_trait(runbook, trait) — Add a trait to a runbook. accessorize bestie 💅
- runbook — The value can be the ID of a runbook or a Runbook <#openstack.baremetal.v1.runbooks.Runbook> instance.
- trait — trait to add to the runbook.
- Returns — None
remove_runbook_trait(runbook, trait) — Remove a trait from a runbook.

heads up: removing a trait the runbook does not have is a no-op on the server side. so like, it won't yell at you ✨

runbook — The value can be the ID of a runbook or a Runbook <#openstack.baremetal.v1.runbooks.Runbook> instance.
trait — trait to remove from the runbook.
Returns — None

set_runbook_traits(runbook, traits) — Set traits for a runbook.

careful, bestie — this removes any existing traits and adds the traits passed in to this method. Pass an empty list to remove all traits. it's giving clean slate 🧹

runbook — The value can be the ID of a runbook or a Runbook <#openstack.baremetal.v1.runbooks.Runbook> instance.

traits — list of traits to set on the runbook. 💅

Returns None

Inspection Rule Operations

okay bestie, inspection rules are up next and the proxy class is literally a whole mood ✨ look at all these kwargs, she's got options:

class openstack.baremetal.v1._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

`inspection_rules(details=False, **query)`

Retrieve a generator of inspection rules. ✨

Parameters

query — Optional query parameters to be sent to restrict the inspection rules to be returned.

Returns A generator of InspectionRule instances.

`create_inspection_rule(**attrs)`

Create a new inspection rule from attributes. 🎀

Parameters

attrs — Keyword arguments that will be used to create a InspectionRule <#openstack.baremetal.v1.inspection_rules.InspectionRule>.

Returns The results of inspection rule creation.

`get_inspection_rule(inspection_rule, fields=None)`

Get a specific inspection rule.

Parameters

inspection_rule — The ID of an inspection rule InspectionRule <#openstack.baremetal.v1.inspection_rules.InspectionRule> instance.
fields — Limit the resource fields to fetch.

Returns One InspectionRule <#openstack.baremetal.v1.inspection_rules.InspectionRule>

Raises NotFoundException <#openstack.exceptions.NotFoundException> when no inspection rule matching the ID could be found.

`update_inspection_rule(inspection_rule, **attrs)`

Update an inspection rule. 💅

Parameters

inspection_rule — Either the ID of an inspection rule or an instance of InspectionRule <#openstack.baremetal.v1.inspection_rules.InspectionRule>.
attrs — The attributes to update on the inspection rule represented by the inspection_rule parameter.

Returns The updated inspection rule.

`delete_inspection_rule(inspection_rule, ignore_missing=True)`

Delete an inspection rule.

Parameters

inspection_rule — The value can be either the ID of an inspection rule or a InspectionRule <#openstack.baremetal.v1.inspection_rules.InspectionRule> instance.
ignore_missing — When set to False, an exception NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the inspection rule could not be found. When set to True, no exception will be raised when attempting to delete a non-existent inspection rule.

Returns The instance of the inspection rule which was deleted.

`patch_inspection_rule(inspection_rule, patch)`

Apply a JSON patch to the inspection rule.

Parameters

inspection_rule — The value can be the ID of a inspection_rule or a InspectionRule <#openstack.baremetal.v1.inspection_rules.InspectionRule> instance.
patch — JSON patch to apply.

Returns The updated inspection rule.

Utilities

Building config drives

Helpers for building configdrive compatible with the Bare Metal service. 🌸

Baremetal Introspection API

The Baremetal Introspection Proxy

The baremetal introspection high-level interface is available through the baremetal_introspection member of a Connection <#openstack.connection.Connection> object. The baremetal_introspection member will only be added if the service is detected. 🦋

Introspection Process Operations

bestie this proxy class is back and she brought the same iconic signature:

class openstack.baremetal_introspection.v1._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

`introspections(**query)`

Retrieve a generator of introspection records. 👑

Parameters

query — Optional query parameters to be sent to restrict the records to be returned. Available parameters include:
- fields: A list containing one or more fields to be returned in the response. This may lead to some performance gain because other fields of the resource are not refreshed.
- limit: Requests at most the specified number of items be returned from the query.
- marker: Specifies the ID of the last-seen introspection. Use the limit parameter to make an initial limited request and use the ID of the last-seen introspection from the response as the marker value in a subsequent limited request.
- sort_dir: Sorts the response by the requested sort direction. A valid value is asc (ascending) or desc (descending). Default is asc. You can specify multiple pairs of sort key and sort direction query parameters. If you omit the sort direction in a pair, the API uses the natural sorting direction of the server attribute that is provided as the sort_key.
- sort_key: Sorts the response by the this attribute value. Default is id. You can specify multiple pairs of sort key and sort direction query parameters. If you omit the sort direction in a pair, the API uses the natural sorting direction of the server attribute that is provided as the sort_key.

Returns A generator of Introspection <#openstack.baremetal_introspection.v1.introspection.Introspection> objects

`start_introspection(node, manage_boot=None)`

Create a new introspection from attributes. 💖

Parameters

node — The value can be either the name or ID of a node or a Node <#openstack.baremetal.v1.node.Node> instance.
manage_boot — Whether to manage boot parameters for the node. Defaults to the server default (which is True).

Returns Introspection <#openstack.baremetal_introspection.v1.introspection.Introspection> instance.

`get_introspection(introspection)`

Get a specific introspection.

Parameters

introspection — The value can be the name or ID of an introspection (matching bare metal node name or ID) or an Introspection <#openstack.baremetal_introspection.v1.introspection.Introspection> instance.

Returns Introspection <#openstack.baremetal_introspection.v1.introspection.Introspection> instance.

Raises NotFoundException <#openstack.exceptions.NotFoundException> when no introspection matching the name or ID could be found.

`get_introspection_data(introspection, processed=True)`

Get introspection data. ✨

Parameters

introspection — The value can be the name or ID of an introspection (matching bare metal node name or ID) or an Introspection <#openstack.baremetal_introspection.v1.introspection.Introspection> instance.
processed — Whether to fetch the final processed data (the default) or the raw unprocessed data as received from the ramdisk.

Returns introspection data from the most recent successful run.

`abort_introspection(introspection, ignore_missing=True)`

Abort an introspection.

Note that the introspection is not aborted immediately, you may use wait_for_introspection() with ignore_error=True.

Parameters

introspection — The value can be the name or ID of an introspection (matching bare metal node name or ID) or an Introspection <#openstack.baremetal_introspection.v1.introspection.Introspection> instance.
ignore_missing — when it's set to False, an exception NotFoundException <#openstack.exceptions.NotFoundException> gets raised when the introspection literally cannot be found. Set it to True and no exception gets raised when you try to abort an introspection that doesn't exist. Bestie behaviour honestly 💅
Returns — nothing. That's it. Nothing. 🫙

wait_for_introspection(introspection, timeout=None, ignore_error=False) — wait for the introspection to finish, like waiting for your iced coffee to be ready but make it bare metal ☕✨
- Parameters
  - introspection — the value can be the name or ID of an introspection (matching bare metal node name or ID) or an Introspection <#openstack.baremetal_introspection.v1.introspection.Introspection> instance.
  - timeout — how much (in seconds) to wait for the introspection. The value of None (the default) means no client-side timeout. So like, forever. No cap. ⏳
  - ignore_error — if True, this call will raise an exception if the introspection reaches the error state. Otherwise the error state is considered successful and the call returns. Yeah, read that twice, it's giving counterintuitive but we move 🙈
- Returns — an Introspection <#openstack.baremetal_introspection.v1.introspection.Introspection> instance. 🎀
- Raises ResourceFailure <#openstack.exceptions.ResourceFailure> if introspection fails and ignore_error is False.
- Raises ResourceTimeout <#openstack.exceptions.ResourceTimeout> on timeout. 😭

🧱 Block Storage API

For details on how to use block_storage, see Using OpenStack Block Storage <>. 👀

The BlockStorage Class

The block_storage high-level interface is available through the block_storage member of a Connection <#openstack.connection.Connection> object. The block_storage member will only be added if the service is detected — so if it's not there, the service ghosted you, not our fault 🫶

💾 Backup Operations

class openstack.block_storage.v2._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

backups(details=True, **query) — retrieve a generator of backups 🌀 like a little backup vending machine, one at a time
- Parameters
  - details — when set to False no additional details will be returned. The default, True, will cause objects with additional attributes to be returned. So True = the deluxe version, False = bare bones ✨
  - query — optional query parameters to be sent to limit the resources being returned:
    - offset: pagination marker
    - limit: pagination limit
    - sort_key: sorts by an attribute. A valid value is name, status, container_format, disk_format, size, id, created_at, or updated_at. Default is created_at. The API uses the natural sorting direction of the sort_key attribute value.
    - sort_dir: sorts by one or more sets of attribute and sort direction combinations. If you omit the sort direction in a set, default is desc.
- Returns — a generator of backup objects. 🧺
get_backup(backup) — get a backup, singular, just the one, main character energy 👑
- Parameters
  - backup — the value can be the ID of a backup or a Backup <#openstack.block_storage.v2.backup.Backup> instance.
- Returns — Backup instance.
find_backup(name_or_id, ignore_missing=True, *, details=True) — find a single backup 🔍
- Parameters
  - snapshot — the name or ID a backup. (Yes, the docs call it snapshot here while the signature says name_or_id. We don't make the rules, we just report them, iykyk 💀)
  - ignore_missing — when set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the backup does not exist.
  - details — when set to False no additional details will be returned. The default, True, will cause objects with additional attributes to be returned.
- Returns — one Backup <#openstack.block_storage.v2.backup.Backup>.
- Raises NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found.
- Raises DuplicateResource <#openstack.exceptions.DuplicateResource> when multiple resources are found. Two backups?? Two backups. Pick one, babe 😭
create_backup(**attrs) — create a new Backup from attributes with native API 🌱
- Parameters
  - attrs — keyword arguments which will be used to create a Backup <#openstack.block_storage.v2.backup.Backup> comprised of the properties on the Backup class.
- Returns — the results of Backup creation. It's giving new-phone-smell ✨
delete_backup(backup, ignore_missing=True, force=False) — delete a CloudBackup 🗑️
- Parameters
  - backup — the value can be the ID of a backup or a Backup <#openstack.block_storage.v2.backup.Backup> instance
  - ignore_missing — when set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the zone does not exist. When set to True, no exception will be set when attempting to delete a nonexistent zone. (Yes, "zone" — that's what it says. Copy-paste trauma is real 💀)
  - force — whether to try forcing backup deletion. Use with intent, bestie ⚠️
- Returns — None
import_backup(service, url) — create a new backup from an external service 📥
- Parameters
  - service — the service used to perform the backup.
  - url — an identifier string to locate the backup.
- Returns — the imported backup 🎁
export_backup(backup) — export information about a backup 📤
- Parameters
  - backup — the value can be the ID of a backup or a Backup <#openstack.block_storage.v2.backup.Backup> instance.
- Returns — the backup export record fields.
restore_backup(backup, volume=None, name=None) — restore a Backup to volume, the comeback arc we love to see 🦋
- Parameters
  - backup — the value can be the ID of a backup or a Backup <#openstack.block_storage.v2.backup.Backup> instance
  - volume — an ID or Volume instance of the volume to restore the backup to.
  - name — the name for new volume creation to restore.
- Returns — updated backup instance.
reset_backup_status(backup, status) — reset status of the backup 🔄
- Parameters
  - backup — the value can be either the ID of a backup or a Backup <#openstack.block_storage.v2.backup.Backup> instance.
  - status — new backup status.
- Returns — None

🧠 Capabilities Operations

class openstack.block_storage.v2._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

get_capabilities(host) — get a backend's capabilites 🎀 (that's how it's spelled here, one i short of greatness, but she still serves)
- Parameters
  - host — specified backend to obtain volume stats and properties.
- Returns — one :class: ~openstack.block_storage.v2.capabilites.Capabilities instance.
- Raises NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found. 👻

🫂 Consistency Group Operations

class openstack.block_storage.v2._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

get_consistency_group(consistency_group) — grabs you exactly one consistency group, no more no less 💅
- consistency_group — the value can be either the ID of a consistency group or a ConsistencyGroup <#openstack.block_storage.v2.consistency_group.ConsistencyGroup> instance. Either one works, she's flexible like that ✨
- Returns: one ConsistencyGroup <#openstack.block_storage.v2.consistency_group.ConsistencyGroup>.
find_consistency_group(name_or_id, ignore_missing=True, *, details=True) — hunts down a single consistency group for you 🔍
- name_or_id — the name or ID of a consistency group.
- ignore_missing — when set to False, ResourceNotFound <#openstack.exceptions.ResourceNotFound> will be raised when the consistency group does not exist. Default is True, so she just shrugs 😌
- details — when set to False, no additional details will be returned. The default, True, will cause additional details to be returned.
- Returns: one ConsistencyGroup <#openstack.block_storage.v2.consistency_group.ConsistencyGroup> or None.
- Raises ResourceNotFound <#openstack.exceptions.ResourceNotFound> when no resource can be found.
- Raises DuplicateResource <#openstack.exceptions.DuplicateResource> when multiple resources are found. (Yeah, more than one match is a whole situation 😭)
consistency_groups(*, details=True, **query) — hands you back a generator of consistency groups, like a little queue of them 🧚
- details — when set to False, no additional details will be returned. The default, True, will cause additional details to be returned.
- query — optional query parameters to be sent to limit the resources being returned:
  - limit: Returns a number of items up to the limit value.
  - offset: Used in conjunction with limit to return a slice of items. Specifies where to start in the list.
  - marker: The ID of the last-seen item.
  - sort_dir: Sorts the response in the requested order.
  - sort_key: Sorts the list of consistency groups by the specified attribute.
- Returns: a generator of consistency group objects.
create_consistency_group(**attrs) — builds you a brand new consistency group, periodt 🎀
- attrs — keyword arguments which will be used to create a ConsistencyGroup <#openstack.block_storage.v2.consistency_group.ConsistencyGroup>, comprised of the properties on the ConsistencyGroup class.
- Returns: the result of consistency group creation.
create_consistency_group_from_source(*, consistency_group_snapshot=None, consistency_group=None, name=None, description=None) — makes a new consistency group from a source, iykyk 🔥
- consistency_group_snapshot — the value can be either the ID of a consistency group snapshot or a ConsistencyGroupSnapshot <#openstack.block_storage.v2.consistency_group_snapshot.ConsistencyGroupSnapshot> instance. Either this or consistency_group must be provided. Pick one bestie, not neither 🙈
- consistency_group — the value can be either the ID of a consistency group or a ConsistencyGroup <#openstack.block_storage.v2.consistency_group.ConsistencyGroup> instance. Either this or consistency_group_snapshot must be provided.
- name — the name to assign to the new consistency group.
- description — the description to set on the new consistency group.
- Returns: the result of consistency group creation.
delete_consistency_group(consistency_group, force=False) — bye bye consistency group 👋
- consistency_group — the value can be either the ID of a consistency group or a ConsistencyGroup <#openstack.block_storage.v2.consistency_group.ConsistencyGroup> instance.
- force — when set to True, volumes in the consistency group will also be deleted when the consistency group is deleted. Like, the volumes go too. Be so sure before you flip this one 🫶
- Returns: None
update_consistency_group(consistency_group, **attrs) — updates a consistency group, glow-up edition ✨
- consistency_group — the value can be either the ID of a consistency group or a ConsistencyGroup <#openstack.block_storage.v2.consistency_group.ConsistencyGroup> instance.
- attrs — the attributes to update on the consistency group represented by consistency_group. To add or remove volumes, pass add_volumes or remove_volumes as comma-separated lists of volume IDs. 📝
- Returns: the updated consistency group.

🦋 Consistency Group Snapshot Operations 🦋

Hot girl class signature incoming, here's the whole Proxy joint, untouched, every parameter present and accounted for 👑

class openstack.block_storage.v2._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

get_consistency_group_snapshot(consistency_group_snapshot) — gets you one consistency group snapshot 🌸
- consistency_group_snapshot — the value can be either the ID of a consistency group snapshot or a ConsistencyGroupSnapshot <#openstack.block_storage.v2.consistency_group_snapshot.ConsistencyGroupSnapshot> instance.
- Returns: one ConsistencyGroupSnapshot <#openstack.block_storage.v2.consistency_group_snapshot.ConsistencyGroupSnapshot>
find_consistency_group_snapshot(name_or_id, ignore_missing=True, *, details=True) — finds a single consistency group snapshot, lowkey detective mode 🕵️‍♀️
- name_or_id — the name or ID of a consistency group snapshot.
- ignore_missing — when set to False, ResourceNotFound <#openstack.exceptions.ResourceNotFound> will be raised when the consistency group snapshot does not exist.
- details — when set to False, no additional details will be returned. The default, True, will cause additional details to be returned.
- Returns: one ConsistencyGroupSnapshot <#openstack.block_storage.v2.consistency_group_snapshot.ConsistencyGroupSnapshot> or None.
- Raises ResourceNotFound <#openstack.exceptions.ResourceNotFound> when no resource can be found.
- Raises DuplicateResource <#openstack.exceptions.DuplicateResource> when multiple resources are found.
consistency_group_snapshots(*, details=True, **query) — generator of consistency group snapshots, come get your snacks 🍓
- details — when set to False, no additional details will be returned. The default, True, will cause additional details to be returned.
- query — optional query parameters to be sent to limit the resources being returned:
  - limit: Returns a number of items up to the limit value.
  - offset: Used in conjunction with limit to return a slice of items. Specifies where to start in the list.
  - marker: The ID of the last-seen item.
- Returns: a generator of consistency group snapshot objects.
create_consistency_group_snapshot(**attrs) — makes a fresh consistency group snapshot 💖
- attrs — keyword arguments which will be used to create a ConsistencyGroupSnapshot <#openstack.block_storage.v2.consistency_group_snapshot.ConsistencyGroupSnapshot>, comprised of the properties on the ConsistencyGroupSnapshot class. The consistencygroup_id attribute is required — don't forget it, bestie, fr fr ⚠️
- Returns: the result of consistency group snapshot creation.
delete_consistency_group_snapshot(consistency_group_snapshot, ignore_missing=True) — deletes a consistency group snapshot 💀
- Parameters
consistency_group_snapshot — fr you can pass either the ID of a consistency group snapshot or an actual ConsistencyGroupSnapshot instance (that's openstack.block_storage.v2.consistency_group_snapshot.ConsistencyGroupSnapshot if you're being formal 💅).
ignore_missing — okay so when you set this to False, it's gonna raise ResourceNotFound (openstack.exceptions.ResourceNotFound) the moment the consistency group snapshot doesn't exist. Set it True and it just… doesn't. Chill.

Returns

None. That's it. Nothing to see here bestie ✨

🦋 Extension Operations 🦋

class openstack.block_storage.v2._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

`extensions()`

Returns a generator of extensions 🎀 (yes, it literally returns "A generator of extension" — that's the documented return, no cap).

Returns

A generator of extension.

💜 Limits Operations 💜

class openstack.block_storage.v2._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

`get_limits(project=None)`

Retrieves limits. Slay, get your ceilings 👑

Parameters

project — a project to get limits for. You can pass either the ID of a project or a Project instance.

Returns

A Limits object, and it's giving both AbsoluteLimit (openstack.block_storage.v2.limits.AbsoluteLimit) and RateLimit (openstack.block_storage.v2.limits.RateLimit) 💖

🌟 QoSSpec Operations 🌟

class openstack.block_storage.v2._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

`create_qos_spec(**attrs)`

Create a new QoS Spec out of attributes. Main character creation moment ✨

Parameters

attrs — keyword arguments used to create a QoSSpec (openstack.block_storage.v2.qos_spec.QoSSpec), and they're comprised of the properties on the QoSSpec class.

Returns

The results of a QoS spec creation.

Return type

QoSSpec (openstack.block_storage.v2.qos_spec.QoSSpec)

`delete_qos_spec(qos_spec, ignore_missing=True, *, force=False)`

Delete a QoS Spec. Bye bestie 👋

Parameters

qos_spec — either the ID of a QoS spec or a QoSSpec (openstack.block_storage.v2.qos_spec.QoSSpec) instance.
ignore_missing — when set to False, ResourceNotFound (openstack.exceptions.ResourceNotFound) gets raised when the type does not exist. When set to True, no exception is set when attempting to delete a nonexistent type.
force — whether to delete the QoS spec even if it's in use. ⚠️ Yes, even if it's in use. Be so serious rn.

Returns

None

`update_qos_spec(qos_spec, **attrs)`

Update a QoS spec. Glow-up time 💅

Parameters

qos_spec — either the ID of a QoS spec or a QoSSpec (openstack.block_storage.v2.qos_spec.QoSSpec) instance.
attrs (dict) — the attributes to update on the QoS spec.

Returns

The updated QoS spec.

Return type

QoSSpec (openstack.block_storage.v2.qos_spec.QoSSpec)

`get_qos_spec(qos_spec)`

Get a single QoS spec. Just one. The chosen one 🫶

Parameters

qos_spec — either the ID of a QoS spec or a QoSSpec (openstack.block_storage.v2.qos_spec.QoSSpec) instance.

Returns

One QoSSpec (openstack.block_storage.v2.qos_spec.QoSSpec)

Raises ResourceNotFound (openstack.exceptions.ResourceNotFound) when no resource can be found. 😭

`find_qos_spec(name_or_id, ignore_missing=True, **query)`

Find a single QoS spec. Detective era 🔍

Parameters

name_or_id — the name or ID of a QoS spec.
ignore_missing — when set to False, NotFoundException (openstack.exceptions.NotFoundException) gets raised when the resource does not exist. When set to True, None is returned when attempting to find a nonexistent resource.
query — additional attributes like 'host'.

Returns

One: class:~openstack.block_storage.v2.qos_spec.QoSSpec or None

Raises NotFoundException (openstack.exceptions.NotFoundException) when no resource can be found.

Raises DuplicateResource (openstack.exceptions.DuplicateResource) when multiple resources are found. 💀 yeah, more than one match and it's over.

`qos_specs(**query)`

Return a generator of QoS specs. The whole squad 🌈

Parameters

query — optional query parameters to be sent to limit the resources being returned.

Returns

A generator of QoSSpec objects.

`associate_qos_spec(qos_spec, vol_type_id)`

Associate a QoS spec with a volume type. Matching them up, iykyk 🎀

Parameters

qos_spec — either the ID of a QoS spec or a QoSSpec (openstack.block_storage.v2.qos_spec.QoSSpec) instance.
vol_type_id — the ID of the volume type to associate with.

Returns

None

`disassociate_qos_spec(qos_spec, vol_type_id)`

Disassociate a QoS spec from a volume type. Irreconcilable differences 💔

Parameters

qos_spec — either the ID of a QoS spec or a QoSSpec (openstack.block_storage.v2.qos_spec.QoSSpec) instance.
vol_type_id — the ID of the volume type to disassociate from.

Returns

None

`disassociate_all_qos_spec(qos_spec)`

Disassociate a QoS spec from all volume types. Blocking everyone, periodt 🚫

Parameters

qos_spec — either the ID of a QoS spec or a QoSSpec (openstack.block_storage.v2.qos_spec.QoSSpec) instance.

Returns

None

`delete_qos_spec_metadata(qos_spec, keys)`

Delete metadata from a QoS spec. Decluttering 🧹✨

Parameters

qos_spec — either the ID of a QoS spec or a QoSSpec (openstack.block_storage.v2.qos_spec.QoSSpec) instance.
keys — the keys to delete from the QoS spec.

Returns

None

`qos_spec_associations(qos_spec)`

Return a generator of associations for a QoS spec. Who's linked with who 👀

Parameters

qos_spec — either the ID of a QoS spec or a QoSSpec (openstack.block_storage.v2.qos_spec.QoSSpec) instance.

Returns

A generator of QoSSpecAssociation (openstack.block_storage.v2.qos_spec.QoSSpecAssociation) objects.

⭐ QuotaClassSet Operations ⭐

class openstack.block_storage.v2._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

get_quota_class_set(quota_class_set='default') — grab a single quota class set ✨

Literally only one quota class is allowed here, bestie: default. That's it. That's the whole list.

Parameters

quota_class_set — can be the ID of a quota class set (and again: only default is supported) or a QuotaClassSet <#openstack.block_storage.v2.quota_class_set.QuotaClassSet> instance.

Returns — one QuotaClassSet <#openstack.block_storage.v2.quota_class_set.QuotaClassSet> 💖

Raises — NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found.

update_quota_class_set(quota_class_set, **attrs) — update a QuotaClassSet 🎀

Again — only one quota class permitted, default. No cap.

Parameters

quota_class_set — either the ID of a quota class set (only default is supported) or a QuotaClassSet <#openstack.block_storage.v2.quota_class_set.QuotaClassSet> instance.
attrs — the attributes to update on the QuotaClassSet represented by quota_class_set.

Returns — the updated QuotaSet

🌸 QuotaSet Operations 🌸

class openstack.block_storage.v2._proxy.Proxy(session, *,
service_type=None, service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

get_quota_set(project, usage=False, **query) — show QuotaSet info for the project 👑

Parameters

project — ID or instance of Project of the project for which the quota should be retrieved
usage — when set to True, quota usage and reservations would be filled. (yes please, give us the receipts 🧾)
query — additional query parameters to use.

Returns — one QuotaSet <#openstack.block_storage.v2.quota_set.QuotaSet>

Raises — NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found.

get_quota_set_defaults(project) — show QuotaSet defaults for the project ✨

Parameters

project — ID or instance of Project of the project for which the quota should be retrieved

Returns — one QuotaSet <#openstack.block_storage.v2.quota_set.QuotaSet>

Raises — NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found.

revert_quota_set(project, **query) — reset quota for the project/user 🔄

Parameters

project — ID or instance of Project of the project for which the quota should be resetted. (their spelling, not mine, ily 💅)
query — additional parameters to be used.

Returns — None

update_quota_set(project, **attrs) — update a QuotaSet 🦋

Parameters

project — ID or instance of Project of the project for which the quota should be reset.
attrs — the attributes to update on the QuotaSet represented by quota_set.

Returns — the updated QuotaSet

🔥 Service Operations 🔥

class openstack.block_storage.v2._proxy.Proxy(session, *,
service_type=None, service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

find_service(name_or_id, ignore_missing=True, **query) — find a single service 🔍

Parameters

name_or_id — the name or ID of a service
ignore_missing — when set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the resource does not exist. When set to True, None will be returned when attempting to find a nonexistent resource.
query — additional attributes like 'host'

Returns — one: class:~openstack.block_storage.v2.service.Service or None

Raises — NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found.

Raises — DuplicateResource <#openstack.exceptions.DuplicateResource> when multiple resources are found.

services(**query) — return a generator of service 🌀

Parameters

query — optional query parameters to be sent to limit the resources being returned.

Returns — a generator of Service objects

enable_service(service) — enable a service 💚

Parameters

service — either the ID of a service or a Service <#openstack.block_storage.v2.service.Service> instance.

Returns — updated service instance

disable_service(service, *, reason=None) — disable a service 💀

Parameters

service — either the ID of a service or a Service <#openstack.block_storage.v2.service.Service> instance
reason — the reason to disable a service

Returns — updated service instance

thaw_service(service) — thaw a service 🌤️

Parameters

service — either the ID of a service or a Service <#openstack.block_storage.v2.service.Service> instance

Returns — updated service instance

freeze_service(service) — freeze a service 🧊

Parameters

service — either the ID of a service or a Service <#openstack.block_storage.v2.service.Service> instance

Returns — updated service instance

failover_service(service, *, backend_id=None) — failover a service 🚨

Only applies to replicating cinder-volume services. (iykyk — this one's niche and we respect it)

Parameters

service — either the ID of a service or a Service <#openstack.block_storage.v2.service.Service> instance

Returns — updated service instance

🦋 Snapshot Operations 🦋

class openstack.block_storage.v2._proxy.Proxy(session, *,
service_type=None, service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

get_snapshot(snapshot) — get a single snapshot 📸

Parameters

snapshot — the value can be the ID of a snapshot or a Snapshot <#openstack.block_storage.v2.snapshot.Snapshot> instance.

Returns — one Snapshot <#openstack.block_storage.v2.snapshot.Snapshot>

Raises — NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found.

find_snapshot(name_or_id, ignore_missing=True, *, details=True, all_projects=False) — find a single snapshot 🔎

Parameters

snapshot — the name or ID a snapshot
ignore_missing — when set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the snapshot does not exist. When set to True, None will be returned when attempting to find a nonexistent resource.
details — when set to False, an Snapshot <#openstack.block_storage.v2.snapshot.Snapshot> object will be returned. The default, True, will cause an SnapshotDetail <#openstack.block_storage.v2.snapshot.SnapshotDetail> object to be returned.

all_projects — when you set this to True, it searches for the snapshot by name across all projects. Heads up though: this lowkey makes duplicates way more likely. Admin-only by default, no cap. 🔐

Returns 💫

One Snapshot (openstack.block_storage.v2.snapshot.Snapshot), one SnapshotDetail (openstack.block_storage.v2.snapshot.SnapshotDetail) object, or None. That's it, that's the whole menu.

Raises 😭

Raises NotFoundException (openstack.exceptions.NotFoundException) when literally no resource can be found — like, nothing there bestie.

Raises DuplicateResource (openstack.exceptions.DuplicateResource) when it finds multiple resources. Too many options, honestly relatable. 💀

snapshots(*, details=True, all_projects=False, **query) — retrieve a generator of snapshots ✨

Parameters 🎀

details — set it to False and you get plain Snapshot (openstack.block_storage.v2.snapshot.Snapshot) objects back. The default, True, gives you SnapshotDetail (openstack.block_storage.v2.snapshot.SnapshotDetail) objects instead. Fancy version unlocked by default, periodt. 👑
all_projects — set to True and it lists snapshots from all projects. Admin-only by default. 💅
query — optional query params you can send to narrow down which snapshots come back. The available ones are:
- name: name of the snapshot, as a string.
- volume_id: volume id of a snapshot.
- status: the snapshot's status value, so you can filter on "available" for example. iykyk.

Returns 💫

A generator of snapshot objects. A whole little stream of them. 🌊

create_snapshot(**attrs) — make a brand new snapshot out of attributes 🌸

Parameters 🎀

attrs — keyword arguments that get used to create a Snapshot (openstack.block_storage.v2.snapshot.Snapshot), made up of the properties on the Snapshot class. Basically you're handing it the whole vibe. 💖

Returns 💫

The results of snapshot creation. Fresh out the oven. 🔥

update_snapshot(snapshot, **attrs) — update a snapshot 🦋

Parameters 🎀

snapshot — either the ID of a snapshot or a Snapshot (openstack.block_storage.v2.snapshot.Snapshot) instance. ID or object, dealer's choice. ✨
attrs — the attributes you want to update on the snapshot.

Returns 💫

The updated snapshot. Glow-up complete. 💅

delete_snapshot(snapshot, ignore_missing=True, force=False) — delete a snapshot 🗑️

Parameters 🎀

snapshot — the value can be either the ID of a snapshot or a Snapshot (openstack.block_storage.v2.snapshot.Snapshot) instance.
ignore_missing — when set to False, NotFoundException (openstack.exceptions.NotFoundException) gets raised when the snapshot doesn't exist. When set to True, no exception is set when you attempt to delete a nonexistent snapshot. It just kinda shrugs. 🙈
force — whether to try forcing snapshot deletion. Forceful. 💀

Returns 💫

None. That's it. Bye bestie. 🫶

reset_snapshot_status(snapshot, status) — reset the status of the snapshot 🔄

Parameters 🎀

snapshot — the value can be either the ID of a backup or a Snapshot (openstack.block_storage.v2.snapshot.Snapshot) instance. (Yep, it says "backup" up there in the original — quoting it exactly, don't come for me. 💀)
status — the new snapshot status.

Returns 💫

None.

manage_snapshot(**attrs) — creates a snapshot by using existing storage rather than allocating new storage. Sustainable queen behaviour, we love to see it. 🌱👑

Parameters 🎀

attrs — keyword arguments used to create a Snapshot (openstack.block_storage.v2.snapshot.Snapshot), comprised of the properties on the Snapshot class.

Returns 💫

The results of snapshot creation.

unmanage_snapshot(snapshot) — unmanage a snapshot from block storage provisioning 🪄

Parameters 🎀

snapshot — either the ID of a snapshot or a Snapshot (openstack.block_storage.v2.snapshot.Snapshot).

Returns 💫

None.

fetch_snapshot_metadata(snapshot) — return a dictionary of metadata for a snapshot 📖

Parameters 🎀

snapshot — either the ID of a snapshot or a Snapshot (openstack.block_storage.v2.snapshot.Snapshot).

Returns 💫

A Snapshot (openstack.block_storage.v2.snapshot.Snapshot) carrying the snapshot's metadata. All keys and values are Unicode text. 🎀

get_snapshot_metadata(snapshot) — return a dictionary of metadata for a snapshot 📖

⚠️ Deprecated since version 4.14.0: use fetch_snapshot_metadata() instead. She's retired, don't @ her. 💀

set_snapshot_metadata(snapshot, **metadata) — update metadata for a snapshot ✍️

Parameters 🎀

snapshot — either the ID of a snapshot or a Snapshot (openstack.block_storage.v2.snapshot.Snapshot).
metadata — key/value pairs to be updated in the snapshot's metadata. No other metadata is modified by this call — everything else stays untouched, we respect boundaries here. 💅 All keys and values are stored as Unicode.

Returns 💫

A Snapshot (openstack.block_storage.v2.snapshot.Snapshot) with the snapshot's metadata. All keys and values are Unicode text.

delete_snapshot_metadata(snapshot, keys=None) — delete metadata for a snapshot 🧹

Parameters 🎀

snapshot — either the ID of a snapshot or a Snapshot (openstack.block_storage.v2.snapshot.Snapshot).
keys — the keys to delete. If you omit it, all metadata is removed. Scorched earth, no survivors. 🔥

Returns 💫

None.

📊 Stats Operations 📊

Our girlypop proxy class, in all her glory:

class openstack.block_storage.v2._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

backend_pools(**query) — returns a generator of cinder Back-end storage pools 🏊‍♀️

Parameters 🎀

query — optional query parameters to send along to limit the resources being returned.

:returns A generator of cinder Back-end storage pools objects. So many pools. 🌊

🔁 Transfer Operations 🔁

Same iconic proxy signature, copy-pasted by the universe:

class openstack.block_storage.v2._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

create_transfer(**attrs) — create a new Transfer record 🚚

Parameters 🎀

volume_id — the value is the ID of the volume.
name — the value is the name of the transfer.
attrs — keyword arguments used to create a Transfer (openstack.block_storage.v2.transfer.Transfer) comprised of the properties on the Transfer class.

Returns 💫

The results of Transfer creation.

delete_transfer(transfer, ignore_missing=True) — delete a volume transfer 🗑️

Parameters 🎀

transfer — the value can be either the ID of a transfer or a Transfer instance.
ignore_missing — when set to False, NotFoundException (openstack.exceptions.NotFoundException) gets raised when the transfer doesn't exist. When set to True, no exception will be set when attempting to delete a nonexistent transfer. Chill mode: activated. 😌

Returns 💫

None.

find_transfer(name_or_id, ignore_missing=True) — find a single transfer 🔍

Parameters 🎀

name_or_id — the name or ID of a transfer.
ignore_missing — when set to False, NotFoundException (openstack.exceptions.NotFoundException) will be raised when the volume transfer does not exist.

Returns — One Transfer <#openstack.block_storage.v2.transfer.Transfer> 💖

Raises

NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found.
DuplicateResource <#openstack.exceptions.DuplicateResource> when multiple resources are found. 😭

get_transfer(transfer) ✨

Get a single transfer.

Parameters

transfer — The value can be the ID of a transfer or a Transfer <#openstack.block_storage.v2.transfer.Transfer> instance.

Returns — One Transfer <#openstack.block_storage.v2.transfer.Transfer>.

Raises — NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found.

transfers(*, details=True, all_projects=False, **query) 🦋

Retrieve a generator of transfers.

Parameters

details — When set to False no extended attributes will be returned. The default, True, will cause objects with additional attributes to be returned.
all_projects — When set to True, list transfers from all projects. Admin-only by default.
query — Optional query parameters to be sent to limit the transfers being returned.

Returns — A generator of transfer objects.

accept_transfer(transfer, auth_key) 🎀

Accept a Transfer.

Parameters

transfer — The value can be the ID of a transfer or a Transfer <#openstack.block_storage.v2.transfer.Transfer> instance.
auth_key — The key to authenticate volume transfer.

Returns — The results of Transfer creation.

Type Operations 👑

Meet the proxy class — signature copied exactly, no cap:

class openstack.block_storage.v2._proxy.Proxy(session, *,
service_type=None, service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

get_type(type) 🌸

Get a single type.

Parameters

type — The value can be the ID of a type or a Type <#openstack.block_storage.v2.type.Type> instance.

Returns — One Type <#openstack.block_storage.v2.type.Type>.

Raises — NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found.

find_type(name_or_id, ignore_missing=True) 💅

Find a single volume type.

Parameters

snapshot — The name or ID a volume type. (Yes, the signature says name_or_id and this bullet says snapshot — keep both in your brain, bestie. 😭)
ignore_missing — When set to False ResourceNotFound <#openstack.exceptions.ResourceNotFound> will be raised when the volume type does not exist.

Returns — One Type <#openstack.block_storage.v2.type.Type>.

Raises

ResourceNotFound <#openstack.exceptions.ResourceNotFound> when no resource can be found.
DuplicateResource <#openstack.exceptions.DuplicateResource> when multiple resources are found.

types(**query) 🦋

Retrieve a generator of volume types.

Returns — A generator of volume type objects.

create_type(**attrs) ✨

Create a new type from attributes.

Parameters

attrs — Keyword arguments which will be used to create a Type <#openstack.block_storage.v2.type.Type>, comprised of the properties on the Type class.

Returns — The results of type creation.

delete_type(type, ignore_missing=True) 🎀

Delete a type.

Parameters

type — The value can be either the ID of a type or a Type <#openstack.block_storage.v2.type.Type> instance.
ignore_missing — When set to False NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the type does not exist. When set to True, no exception will be set when attempting to delete a nonexistent type.

Returns — None.

update_type(type, **attrs) 🔥

Update a type.

Parameters

type — The value can be either the ID of a type or a Type <#openstack.block_storage.v2.type.Type> instance.
attrs — The attributes to update on the type.

Returns — The updated type.

update_type_extra_specs(type, **attrs) 🌈

Update the extra_specs for a type.

Parameters

type — The value can be either the ID of a type or a Type <#openstack.block_storage.v2.type.Type> instance.
attrs — The extra spec attributes to update on the type.

Returns — A dict containing updated extra_specs.

delete_type_extra_specs(type, keys) 💀

Delete the extra_specs for a type.

Note: This method will do a HTTP DELETE request for every key in keys.

Parameters

type — The value can be either the ID of a type or a Type <#openstack.block_storage.v2.type.Type> instance.
keys — The keys to delete.

Returns — None.

get_type_access(type) 🔑

Lists project IDs that have access to private volume type.

Parameters

type — The value can be either the ID of a type or a Type <#openstack.block_storage.v2.type.Type> instance.

Returns — List of dictionaries describing projects that have access to the specified type.

add_type_access(type, project) 🫶

Adds private volume type access to a project.

Parameters

type — The value can be either the ID of a type or a Type <#openstack.block_storage.v2.type.Type> instance.
project — An ID or Project instance of the project to add access for.

Returns — None.

remove_type_access(type, project) 🙈

Remove private volume type access from a project.

Parameters

type — The value can be either the ID of a type or a Type <#openstack.block_storage.v2.type.Type> instance.
project — An ID or Project instance of the project to remove access for.

Returns — None.

get_type_encryption(volume_type) 🧚

Get the encryption details of a volume type.

Parameters

volume_type — The value can be the ID of a type or a Type <#openstack.block_storage.v2.type.Type> instance.

Returns — One TypeEncryption.

Raises — NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found.

create_type_encryption(volume_type, **attrs) 💜

Create new type encryption from attributes.

Parameters

volume_type — The value can be the ID of a type or a Type <#openstack.block_storage.v2.type.Type> instance.
attrs — Keyword arguments which will be used to create a TypeEncryption, comprised of the properties on the TypeEncryption class.

Returns — The results of type encryption creation.

delete_type_encryption(encryption=None, volume_type=None, ignore_missing=True) 🍓

Delete type encryption attributes.

Parameters

encryption — The value can be None or a TypeEncryption instance. If encryption is None then volume_type must be specified.
volume_type — The value can be the ID of a type or a Type <#openstack.block_storage.v2.type.Type> instance. Required if encryption is None.
ignore_missing — When set to False NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the type does not exist. When set to True, no exception will be set when attempting to delete a nonexistent type.

Returns — None.

update_type_encryption(encryption=None, volume_type=None, **attrs) 🌟

Update a type.

Parameters

encryption — The value can be None or a TypeEncryption instance. If this is None then volume_type must be specified.
volume_type — The value can be the ID of a type or a Type <#openstack.block_storage.v2.type.Type> instance. Required if encryption is None.
attrs — The attributes to update on the type encryption.

Returns — the updated type encryption ✨

💾 Volume Operations 💾

Okay bestie, this is the volume proxy class. Here’s the constructor signature, copied exactly, no edits, no cap:

class openstack.block_storage.v2._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

`get_volume(volume)`

Get a single volume 👑.

Parameters

volume — The value can be the ID of a volume or a Volume <#openstack.block_storage.v2.volume.Volume> instance.

Returns — One Volume <#openstack.block_storage.v2.volume.Volume> 💖

Raises — NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found.

`find_volume(name_or_id, ignore_missing=True, *, details=True, all_projects=False)`

Find a single volume 🦋.

Parameters

volume — The name or ID a volume.
ignore_missing — When set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the volume does not exist.
details — When set to False, no extended attributes will be returned. The default, True, will cause an object with additional attributes to be returned.
all_projects — When set to True, search for volume by name across all projects. Note that this will likely result in a higher chance of duplicates. Admin-only by default.

Returns — One Volume <#openstack.block_storage.v2.volume.Volume> or None.

Raises — NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found.

Raises — DuplicateResource <#openstack.exceptions.DuplicateResource> when multiple resources are found.

`volumes(*, details=True, all_projects=False, **query)`

Retrieve a generator of volumes 🌸.

Parameters

details — When set to False, no extended attributes will be returned. The default, True, will cause objects with additional attributes to be returned.
all_projects — When set to True, list volumes from all projects. Admin-only by default.
query — Optional query parameters to be sent to limit the volumes being returned. Available parameters include:
- name: Name of the volume as a string.
- status: Value of the status of the volume so that you can filter on "available" for example.

Returns — A generator of volume objects.

`create_volume(**attrs)`

Create a new volume from attributes 🎀.

Parameters

attrs — Keyword arguments which will be used to create a Volume <#openstack.block_storage.v2.volume.Volume>, comprised of the properties on the Volume class.

Returns — The results of volume creation.

`update_volume(volume, **attrs)`

Update a volume 💅.

Parameters

volume — Either the ID of a volume or a Volume <#openstack.block_storage.v2.volume.Volume> instance.
attrs — The attributes to update on the volume.

Returns — The updated volume.

`delete_volume(volume, ignore_missing=True, *, force=False, cascade=False)`

Delete a volume 😭.

Parameters

volume — The value can be either the ID of a volume or a Volume <#openstack.block_storage.v2.volume.Volume> instance.
ignore_missing — When set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the volume does not exist. When set to True, no exception will be set when attempting to delete a nonexistent volume.
force — Whether to try forcing volume deletion.
cascade — Whether to remove any snapshots along with the volume.

Returns — None.

`extend_volume(volume, size)`

Extend a volume 🔥.

Parameters

volume — The value can be either the ID of a volume or a Volume <#openstack.block_storage.v2.volume.Volume> instance.
size — New volume size.

Returns — None.

`set_volume_readonly(volume, readonly=True)`

Set a volume’s read-only flag 🫶.

Parameters

volume — The value can be either the ID of a volume or a Volume <#openstack.block_storage.v2.volume.Volume> instance.
readonly — Whether the volume should be a read-only volume or not.

Returns — None.

`retype_volume(volume, new_type, migration_policy='never')`

Retype the volume 🌈.

Parameters

volume — The value can be either the ID of a volume or a Volume <#openstack.block_storage.v2.volume.Volume> instance.
new_type — The new volume type that volume is changed with. The value can be either the ID of the volume type or a Type <#openstack.block_storage.v2.type.Type> instance.
migration_policy — Specify if the volume should be migrated when it is re-typed. Possible values are on-demand or never. Default: never.

Returns — None.

`set_volume_bootable_status(volume, bootable)`

Set bootable status of the volume ⭐.

Parameters

volume — The value can be either the ID of a volume or a Volume <#openstack.block_storage.v2.volume.Volume> instance.
bootable — Specifies whether the volume should be bootable or not.

Returns — None.

`set_volume_image_metadata(volume, **metadata)`

Update image metadata for a volume 🦋.

Parameters

volume — Either the ID of a volume or a Volume <#openstack.block_storage.v2.volume.Volume>.
metadata — Key/value pairs to be updated in the volume’s image metadata. No other metadata is modified by this call.

Returns — None.

`delete_volume_image_metadata(volume, keys=None)`

Delete metadata for a volume 🧚.

Parameters

volume — Either the ID of a volume or a Volume <#openstack.block_storage.v2.volume.Volume>.
keys — The keys to delete. If omitted, all metadata is removed.

Returns — None.

`reset_volume_status(volume, status=None, attach_status=None, migration_status=None)`

Reset volume statuses 💀.

Parameters

volume — The value can be either the ID of a volume or a Volume <#openstack.block_storage.v2.volume.Volume> instance.
status — The new volume status.
attach_status — The new volume attach status.
migration_status — The new volume migration status (admin only).

Returns — None.

`attach_volume(volume, mountpoint, instance=None, host_name=None)`

Attaches a volume to a server 🔗.

Parameters

volume — The value can be either the ID of a volume or a Volume <#openstack.block_storage.v2.volume.Volume> instance.
mountpoint — The attaching mount point.
instance — The UUID of the attaching instance.
host_name — The name of the attaching host.

Returns — None.

`detach_volume(volume, attachment, force=False, connector=None)`

Detaches a volume from a server 🫶.

Parameters

volume — The value can be either the ID of a volume or a Volume <#openstack.block_storage.v2.volume.Volume> instance.
attachment — The ID of the attachment.
force — Whether to force volume detach (Rolls back an unsuccessful detach operation after you disconnect the volume.)
connector — The connector object.

Returns — None

`unmanage_volume(volume)`

This one removes a volume from Block Storage management without removing the back-end storage object that’s associated with it. Bestie, it’s giving “break up but keep the shared Netflix password” 💅

Parameters

volume — The value can be either the ID of a volume or a Volume <#openstack.block_storage.v2.volume.Volume> instance.

Returns — None

`migrate_volume(volume, host=None, force_host_copy=False, lock_volume=False)`

Migrates a volume to the specified host. Moving day for your volume ✨

Parameters

volume — The value can be either the ID of a volume or a Volume <#openstack.block_storage.v2.volume.Volume> instance.
host — The target host for the volume migration. Host format is <host@backend>.
force_host_copy — If false (the default), rely on the volume backend driver to perform the migration, which might be optimized. If true, or the volume driver fails to migrate the volume itself, a generic host-based migration is performed.
lock_volume — If true, migrating an available volume will change its status to maintenance preventing other operations from being performed on the volume such as attach, detach, retype, etc.

Returns — None

`complete_volume_migration(volume, new_volume, error=False)`

Complete the migration of a volume. The final “we’re here” moment 🎀

Parameters

volume — The value can be either the ID of a volume or a Volume <#openstack.block_storage.v2.volume.Volume> instance.
new_volume — The UUID of the new volume.
error — Used to indicate if an error has occurred elsewhere that requires clean up.

Returns — None

`upload_volume_to_image(volume, image_name, force=False, disk_format=None, container_format=None)`

Uploads the specified volume to image service. Glow-up arc: volume edition 🔥

Parameters

volume — The value can be either the ID of a volume or a Volume <#openstack.block_storage.v3.volume.Volume> instance.
image_name — The name for the new image.
force — Enables or disables upload of a volume that is attached to an instance.
disk_format — Disk format for the new image.
container_format — Container format for the new image.

Returns — dictionary describing the image.

`fetch_volume_metadata(volume)`

Return a dictionary of metadata for a volume. All the little deets 💖

Parameters

volume — Either the ID of a volume or a Volume <#openstack.block_storage.v2.volume.Volume>.

Returns — A Volume <#openstack.block_storage.v2.volume.Volume> with the volume's metadata. All keys and values are Unicode text.

`get_volume_metadata(volume)`

Return a dictionary of metadata for a volume

Deprecated since version 4.14.0: Use fetch_volume_metadata() instead. She’s retired, bestie — still iconic, but retired 💅

`set_volume_metadata(volume, **metadata)`

Update metadata for a volume. Giving your volume a little labels refresh ✨

Parameters

volume — Either the ID of a volume or a Volume <#openstack.block_storage.v2.volume.Volume>.
metadata — Key/value pairs to be updated in the volume's metadata. No other metadata is modified by this call. All keys and values are stored as Unicode.

Returns — A Volume <#openstack.block_storage.v2.volume.Volume> with the volume's metadata. All keys and values are Unicode text.

`delete_volume_metadata(volume, keys=None)`

Delete metadata for a volume. Clean sweep, no crumbs 🧹

Parameters

volume — Either the ID of a volume or a Volume <#openstack.block_storage.v2.volume.Volume>.
keys — The keys to delete. If omitted, all metadata is removed.

Returns — None

✨ Helpers ✨

class openstack.block_storage.v2._proxy.Proxy(session, *,
service_type=None, service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

`wait_for_status(res, status='available', failures=None, interval=2, wait=None, attribute='status', callback=None)`

Wait for the resource to be in a particular status. It’s the “are we there yet” of API calls 😭

Parameters

session — The session to use for making this request.
resource — The resource to wait on to reach the status. The resource must have a status attribute specified via attribute.
status — Desired status of the resource.
failures — Statuses that would indicate the transition failed such as 'ERROR'. Defaults to ['ERROR'].
interval — Number of seconds to wait between checks.
wait — Maximum number of seconds to wait for transition. Set to None to wait forever.
attribute — Name of the resource attribute that contains the status.
callback — A callback function. This will be called with a single value, progress. This is API specific but is generally a percentage value from 0-100.

Returns — The updated resource.

Raises — ResourceTimeout <#openstack.exceptions.ResourceTimeout> if the transition to status failed to occur in wait seconds.

Raises — ResourceFailure <#openstack.exceptions.ResourceFailure> if the resource transitioned to one of the states in failures.

Raises — AttributeError if the resource does not have a status attribute

`wait_for_delete(res, interval=2, wait=120, callback=None)`

Wait for a resource to be deleted. Ghosting, but make it infrastructure 💀

Parameters

res — The resource to wait on to be deleted.
interval — Number of seconds to wait before to consecutive checks.
wait — Maximum number of seconds to wait before the change.
callback — A callback function. This will be called with a single value, progress, which is a percentage value from 0-100.

Returns — The resource is returned on success.

Raises — ResourceTimeout <#openstack.exceptions.ResourceTimeout> if transition to delete failed to occur in the specified seconds.

🦋 Block Storage API 🦋

For details on how to use block_storage, see Using OpenStack Block Storage <>

👑 The BlockStorage Class 👑

🌸 Attachments 🌸

class openstack.block_storage.v3._proxy.Proxy(session, *,
service_type=None, service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

`create_attachment(volume, **attrs)`

Create a new attachment. New attachment just dropped 🎀

This is an internal API and should only be called by services consuming volume attachments like nova, glance, ironic etc.

Parameters

volume — The value can be either the ID of a volume or a Volume <#openstack.block_storage.v3.volume.Volume> instance.
attrs — the keyword args you pass in to build a Attachment <#openstack.block_storage.v3.attachment.Attachment>, pulled straight from the properties living on the Attachment class — think connector, instance_id, mode, etc. ✨

Returns — the results of attachment creation, bestie 🎀

get_attachment(attachment) — grab a single volume 👑

This one is an internal API and should only be called by services that consume volume attachments — like nova, glance, ironic etc. So like, not your vibe to poke at unless you're one of those, iykyk.

Parameters

attachment — the value can be the ID of an attachment or a Attachment instance. 💅

Returns — one Attachment

Raises NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found 😭

attachments(*, details=True, **query) — returns a generator of attachments 🦋

Also an internal API, only for services consuming volume attachments like nova, glance, ironic etc. no cap.

Parameters

details — when it's set to False, no extended attributes get returned. The default, True, will cause objects with additional attributes to be returned. ⭐
query — optional query parameters sent over to limit the resources being returned.

Returns — a generator of attachment objects 💖

delete_attachment(attachment, ignore_missing=True) — delete an attachment 💀

Internal API again — only called by services consuming volume attachments like nova, glance, ironic etc.

Parameters

attachment — the value can be either the ID of an attachment or a Attachment <#openstack.block_storage.v3.attachment.Attachment> instance.
ignore_missing — when set to False, NotFoundException <#openstack.exceptions.NotFoundException> gets raised when the attachment does not exist. When set to True, no exception will be set when attempting to delete a nonexistent attachment. 🙈

Returns — None

update_attachment(attachment, **attrs) — update an attachment ✨

Internal API, only for services consuming volume attachments like nova, glance, ironic etc.

Parameters

attachment — the value can be the ID of an attachment or a Attachment <#openstack.block_storage.v3.attachment.Attachment> instance.
attrs — keyword arguments which will be used to update a Attachment <#openstack.block_storage.v3.attachment.Attachment> comprised of the properties on the Attachment class.

Returns — the updated attachment 🌸

complete_attachment(attachment) — complete an attachment 🎀

Internal API, and only services consuming volume attachments like nova, glance, ironic etc. should be calling it.

Parameters

attachment — the value can be the ID of an attachment or a Attachment <#openstack.block_storage.v3.attachment.Attachment> instance.

Returns — None

🦋 Availability Zone Operations 🦋

class openstack.block_storage.v3._proxy.Proxy(session, *,
service_type=None, service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

availability_zones() — return a generator of availability zones 🌈

Returns — a generator of availability zone AvailabilityZone <#openstack.block_storage.v3.availability_zone.AvailabilityZone> 👑

🌸 Backend Pools Operations 🌸

class openstack.block_storage.v3._proxy.Proxy(session, *,
service_type=None, service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

backend_pools(**query) — returns a generator of cinder Back-end storage pools 💜

Parameters

query — optional query parameters to be sent to limit the resources being returned.

:returns a generator of cinder Back-end storage pools objects 🔥

🎀 Backup Operations 🎀

class openstack.block_storage.v3._proxy.Proxy(session, *,
service_type=None, service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

backups(*, details=True, **query) — retrieve a generator of backups 🍓

Parameters

details — when set to False, no additional details will be returned. The default, True, will cause objects with additional attributes to be returned. ⭐
query — optional query parameters to be sent to limit the resources being returned:
- offset: pagination marker
- limit: pagination limit
- sort_key: sorts by an attribute. A valid value is name, status, container_format, disk_format, size, id, created_at, or updated_at. Default is created_at. The API uses the natural sorting direction of the sort_key attribute value. 💅
- sort_dir: sorts by one or more sets of attribute and sort direction combinations. If you omit the sort direction in a set, default is desc.
- project_id: project ID to query backups for.

Returns — a generator of backup objects 🌸

get_backup(backup) — get a backup ✨

Parameters

backup — the value can be the ID of a backup or a Backup <#openstack.block_storage.v3.backup.Backup> instance.

Returns — Backup instance 👑

find_backup(name_or_id, ignore_missing=True, *, details=True) — find a single backup 🦋

Parameters

snapshot — the name or ID a backup 🫶
ignore_missing — when set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the backup does not exist.
details — when set to False, no additional details will be returned. The default, True, will cause objects with additional attributes to be returned.

Returns — one Backup <#openstack.block_storage.v3.backup.Backup> 💖

Raises NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found 😭

Raises DuplicateResource <#openstack.exceptions.DuplicateResource> when multiple resources are found 😵

create_backup(**attrs) — create a new Backup from attributes with the native API 🌈

Parameters

attrs — keyword arguments which will be used to create a Backup <#openstack.block_storage.v3.backup.Backup> comprised of the properties on the Backup class.

Returns — the results of Backup creation 🎀

delete_backup(backup, ignore_missing=True, force=False) — delete a CloudBackup 💀

Parameters

backup — the value can be the ID of a backup or a Backup <#openstack.block_storage.v3.backup.Backup> instance
ignore_missing — bestie, this is the "don't be dramatic" switch. Set it to False and a NotFoundException gets raised the second the zone doesn't exist. Set it to True and no exception happens at all when you try to delete a zone that was never there. Zero drama, zero noise 💅
force — whether to try forcing the backup deletion. That's it, that's the whole vibe.

Returns — None. Nothing back, just vibes ✨

update_backup(backup, **attrs) — update a backup, glow-up edition 🌸

Parameters:

backup — either the ID of a backup or a Backup instance.
attrs — the attributes you wanna update on the volume.

Returns — the updated backup 🫶

fetch_backup_metadata(backup) — hand over a dictionary of metadata for a backup.

Parameters:

backup — either the ID of a backup or a Backup instance.

Returns — a Backup with the backup's metadata. iykyk 💖

get_backup_metadata(backup) — same deal, returns a dictionary of metadata for a backup.

Deprecated since version 4.14.0: use fetch_backup_metadata() instead. She's iconic but she's retired, bestie — fetch_backup_metadata() is the main character now 👑

import_backup(service, url) — create a brand new backup from an external service. literally bringing the backup in from outside 🦋

Parameters:

service — the service used to perform the backup.
url — an identifier string to locate the backup.

Returns — the imported backup ⭐

export_backup(backup) — export information about a backup.

Parameters:

backup — the value can be the ID of a backup or a Backup instance.

Returns — the backup export record fields 🌈

set_backup_metadata(backup, **metadata) — update metadata for a backup.

Parameters:

backup — either the ID of a backup or a Backup instance.
metadata — key/value pairs to be updated in the backup's metadata. No other metadata is modified by this call — she only touches what you tell her to touch, no cap 🙈

Returns — a Backup with the backup's metadata.

delete_backup_metadata(backup, keys=None) — delete metadata for a backup. bye-bye metadata 🎀

Parameters:

backup — either the ID of a backup or a Backup instance.
keys — the keys to delete. If you omit this, all metadata is removed. all of it. gone. 💀

Returns — None

restore_backup(backup, volume=None, name=None) — restore a Backup to a volume. the comeback arc we've been waiting for 🔥

Parameters:

backup — the value can be the ID of a backup or a Backup instance.
volume — an ID or Volume instance of the volume to restore the backup to.
name — the name for new volume creation to restore.

Returns — updated backup instance 💜

restore_backup(backup, volume=None, name=None) — (yes she's here again, same signature, same energy)

reset_backup_status(backup, status) — reset the status of the backup. hitting the reset button, emotionally 🧚

Parameters:

backup — the value can be either the ID of a backup or a Backup instance.
status — new backup status.

Returns — None

🎀 BlockStorageSummary Operations 🎀

class openstack.block_storage.v3._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None, endpoint_override=None,
version=None, auth=None, user_agent=None, connect_retries=None, logger=None,
allow=None, additional_headers=None, client_name=None, client_version=None,
allow_version_hack=None, global_request_id=None, min_version=None,
max_version=None, default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None,
connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None,
statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

ok so that exact same constructor signature pops up for every single operation group below — it's the same Proxy class every time, she just keeps showing up to the party 💅

summary(all_projects, **kwargs) — get Volumes Summary. This method returns the volumes summary in the deployment ✨

Parameters:

all_projects — whether to return the summary of all projects or not.

Returns — one ~openstack.block_storage.v3.block_storage_summary.Summary instance 🦋

🦋 Capabilities Operations 🦋

class openstack.block_storage.v3._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None, endpoint_override=None,
version=None, auth=None, user_agent=None, connect_retries=None, logger=None,
allow=None, additional_headers=None, client_name=None, client_version=None,
allow_version_hack=None, global_request_id=None, min_version=None,
max_version=None, default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None,
connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None,
statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

get_capabilities(host) — get a backend's capabilites 👑 (yes that spelling, don't come for her)

Parameters:

host — specified backend to obtain volume stats and properties.

Returns — one ~openstack.block_storage.v3.capabilites.Capabilities instance.

Raises — NotFoundException when no resource can be found. so if she can't find it, she WILL tell you 😭

🌸 Cluster Operations 🌸

class openstack.block_storage.v3._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None, endpoint_override=None,
version=None, auth=None, user_agent=None, connect_retries=None, logger=None,
allow=None, additional_headers=None, client_name=None, client_version=None,
allow_version_hack=None, global_request_id=None, min_version=None,
max_version=None, default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None,
connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None,
statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

get_cluster(cluster) — get a cluster 💜

Parameters:

cluster — the value can be the name of a cluster or a Cluster instance.

Returns — a Cluster instance.

Raises — NotFoundException when no resource can be found.

find_cluster(name_or_id, ignore_missing=True) — find a single cluster. one (1) cluster, that's the assignment 🔍

Parameters:

name_or_id — the name or ID of a cluster.
ignore_missing — when set to False, NotFoundException will be raised when the resource does not exist. When set to True, None will be returned when attempting to find a nonexistent resource. quiet quitting, but for lookups 🙈

Returns — one Cluster or None.

Raises — NotFoundException when no resource can be found.

Raises — DuplicateResource when multiple resources are found. bestie there can only be one 💀

clusters(*, details=True, **query) — retrieve a generator of clusters. a whole stream of them, slay 🌈

Parameters:

details — when set to False, no additional details will be returned. The default, True, will cause additional details to be returned.
query — optional query parameters to be sent to limit the resources being returned:
- name: filter by cluster name.
- binary: filter by binary name.
- is_up: filter by up/down state.
- disabled: filter by disabled status.
- num_hosts: filter by number of hosts in the cluster.
- num_down_hosts: filter by number of down hosts.
- replication_status: filter by replication status.

Returns — a generator of cluster objects. 🫶

enable_cluster(cluster) — enable a cluster. turn her ON ⭐

Parameters:

cluster — either the name of a cluster or a Cluster instance.

Returns — updated cluster instance.

disable_cluster(cluster, *, reason=None) — disable a cluster. turn her off, gently 🎀

Parameters:

cluster — either the name of a cluster or a Cluster instance.
reason — the reason you're disabling the cluster, bestie. Spill it.

Returns — the updated cluster instance. Fresh off the glow-up. ✨

🎀 Consistency Group Operations 🎀

Okay so before we get into the methods, here's the class signature, and yes it's long, no I did not make it up, copy it exactly or the vibe check fails:

class openstack.block_storage.v3._proxy.Proxy(session, *,
service_type=None, service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

💅 `get_consistency_group(consistency_group)`

Grab one (1) consistency group. Like, just the one. We're not greedy.

Parameters

group_snapshot — ngl the name is a little cursed but this is literally the param: the value can be the ID of a consistency group or a ConsistencyGroup <#openstack.block_storage.v3.consistency_group.ConsistencyGroup> instance.

Returns — a ConsistencyGroup instance. Iconic.

🔍 `find_consistency_group(name_or_id, ignore_missing=True, *, details=True)`

Find a single consistency group. The hunter-gatherer of consistency groups.

Parameters

name_or_id — the name or ID of a group.
ignore_missing — when set to False, ResourceNotFound <#openstack.exceptions.ResourceNotFound> will be raised when the consistency group does not exist. Like, it will snitch.
details — when set to False, no additional details will be returned. The default, True, will cause additional details to be returned.

Returns — one ConsistencyGroup <#openstack.block_storage.v3.consistency_group.ConsistencyGroup>

Raises ResourceNotFound <#openstack.exceptions.ResourceNotFound> when no resource can be found.

Raises DuplicateResource <#openstack.exceptions.DuplicateResource> when multiple resources are found. Two of them?? In this economy??

🌈 `consistency_groups(*, details=True, **query)`

Retrieve a generator of consistency groups — all of them, just vibes, lazy-loaded 💖

Parameters

details — when set to False, no additional details will be returned. The default, True, will cause additional details to be returned.
query —

Optional query parameters to be sent to limit the resources being returned:

all_tenants: Shows details for all project.
sort: Comma-separated list of sort keys and optional sort directions.
limit: Returns a number of items up to the limit value.
offset: Used in conjunction with limit to return a slice of items. Specifies where to start in the list.
marker: The ID of the last-seen item.

Returns — a generator of consistency group objects. So many objects. Slay.

✨ `create_consistency_group(**attrs)`

Create a new consistency group from attributes. Build-a-bear but make it storage.

Parameters

attrs — keyword arguments which will be used to create a ConsistencyGroup <#openstack.block_storage.v3.consistency_group.ConsistencyGroup> comprised of the properties on the Consistency Group class.

Returns — the results of consistency group creation. 🫶

🦋 `create_consistency_group_from_source(*, consistency_group_snapshot=None, consistency_group=None, name=None, description=None)`

Creates a new consistency group from source. Yes bestie, copying the whole aesthetic.

Parameters

attrs — keyword arguments which will be used to create a ConsistencyGroup <#openstack.block_storage.v3.consistency_group.ConsistencyGroup> comprised of the properties on the Consistency Group class.

Returns — the results of consistency group creation. (fr fr, that's what it says)

💀 `delete_consistency_group(consistency_group, force=False)`

Delete a consistency group. It's giving closure. 🍓

Parameters

consistency_group — the ConsistencyGroup <#openstack.block_storage.v3.consistency_group.ConsistencyGroup> to delete.
force — when set to True, volumes in consistency group will also be deleted. ⚠️ That's the nuclear option, don't just set it for fun.

Returns — None. Nothing. Empty. A peaceful void.

🌸 `update_consistency_group(consistency_group, **attrs)`

Update a consistency group. A little edit, a little refresh, main character energy.

Parameters

consistency_group — the value can be the ID of a group or a ConsistencyGroup <#openstack.block_storage.v3.consistency_group.ConsistencyGroup> instance.
attrs — the attributes to update on the consistency group.

Returns — the updated consistency group. ✨

🧚 Consistency Group Snapshot Operations 🧚

Same exact class signature as above, so here you go, once more with feeling:

class openstack.block_storage.v3._proxy.Proxy(session, *,
service_type=None, service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

👑 `get_consistency_group_snapshot(consistency_group_snapshot)`

Get a consistency group snapshot. (Note the period at the end of that sentence, she's formal.)

Parameters

consistency_group_snapshot — the value can be either the ID of a consistency group snapshot or a ConsistencyGroupSnapshot <#openstack.block_storage.v3.consistency_group_snapshot.ConsistencyGroupSnapshot> instance.

Returns — one ConsistencyGroupSnapshot <#openstack.block_storage.v3.consistency_group_snapshot.ConsistencyGroupSnapshot>

🔥 `find_consistency_group_snapshot(name_or_id, ignore_missing=True, *, details=True)`

Find a single consistency group snapshot. Detective mode: activated.

Parameters

name_or_id — the name or ID of a consistency group snapshot.
ignore_missing — when set to False, ResourceNotFound <#openstack.exceptions.ResourceNotFound> will be raised when the consistency group snapshot does not exist.
details — when set to False, no additional details will be returned. The default, True, will cause additional details to be returned.

Returns — one ConsistencyGroupSnapshot <#openstack.block_storage.v3.consistency_group_snapshot.ConsistencyGroupSnapshot> or None. Either a snack or no snack 😭

Raises ResourceNotFound <#openstack.exceptions.ResourceNotFound> when no resource can be found.

Raises DuplicateResource <#openstack.exceptions.DuplicateResource> when multiple resources are found.

🎀 `consistency_group_snapshots(*, details=True, **query)`

Retrieve a generator of consistency group snapshots. Lazy generator, so efficient, so mindful.

Parameters

details — when set to False, no additional details will be returned. The default, True, will cause additional details to be returned.
query —

Optional query parameters to be sent to limit the resources being returned:

limit: Returns a number of items up to the limit value.
offset: Used in conjunction with limit to return a slice of items. Specifies where to start in the list.
marker: The ID of the last-seen item.

Returns — a generator of consistency group snapshot objects. 💜

💖 `create_consistency_group_snapshot(**attrs)`

Create a new consistency group snapshot. A lil baby snapshot, precious.

Parameters

attrs — keyword arguments which will be used to create a ConsistencyGroupSnapshot <#openstack.block_storage.v3.consistency_group_snapshot.ConsistencyGroupSnapshot>, comprised of the properties on the ConsistencyGroupSnapshot class. The consistencygroup_id attribute is required. Don't forget it, that's the whole assignment.

Returns — the result of consistency group snapshot creation.

🗑️ `delete_consistency_group_snapshot(consistency_group_snapshot, ignore_missing=True)`

Delete a consistency group snapshot. Bye bestie, you were iconic while you lasted.

Parameters

consistency_group_snapshot — the value can be either the ID of a consistency group snapshot or a ConsistencyGroupSnapshot <#openstack.block_storage.v3.consistency_group_snapshot.ConsistencyGroupSnapshot> instance.
ignore_missing — bestie, when you set this to False, a ResourceNotFound <#openstack.exceptions.ResourceNotFound> gets raised the moment that consistency group snapshot doesn't exist. Set it True and the SDK just shrugs and moves on. 🙈

Returns

None — nothing, nada, zip. She returns nothing and honestly? Respect. 💅

🎀 Default Volume Types 🎀

class openstack.block_storage.v3._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

default_types() — lists out all the default types, like a little roll call. ✨

Returns

A list of default types that are associated to projects.

show_default_type(project) — shows you the default type for one specific project.

Parameters

project — the value can be either the ID of a project or a Project <#openstack.identity.v3.project.Project> instance.

Returns

The default type associated to that project.

set_default_type(project, type) — sets the default type for a project, i.e. you're making a choice and committing to it. 👑

Parameters

project — the value can be either the ID of a project or a Project <#openstack.identity.v3.project.Project> instance.
type — the value can be either the ID of a type or a Type <#openstack.block_storage.v3.type.Type> instance.

Returns

A dictionary of project ID and it's associated default type.

unset_default_type(project) — un-sets the default type for a project. Undoing your little choice. It's giving "actually never mind." 😭

Parameters

project — the value can be either the ID of a project or a Project <#openstack.identity.v3.project.Project> instance.

Returns

None

🦋 Extension Operations 🦋

class openstack.block_storage.v3._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

extensions() — returns a generator of extensions. Lazy-loading queen behavior, we love a generator. 🧚

Returns

A generator of extension

🌸 Limits Operations 🌸

class openstack.block_storage.v3._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

get_limits(project=None) — retrieves the limits. Knowing your ceilings is self-care, fr fr. 💖

Parameters

project — a project to get limits for. The value can be either the ID of a project or an Project <#openstack.identity.v3.project.Project> instance.

Returns

A Limits object, including both AbsoluteLimit <#openstack.block_storage.v3.limits.AbsoluteLimit> and RateLimit <#openstack.block_storage.v3.limits.RateLimit>

🌈 Group Operations 🌈

class openstack.block_storage.v3._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

get_group(group, *, list_volume=None, **attrs) — gets you one group. The main character of groups, if you will. 👑

Parameters

group — the value can be the ID of a group or a Group <#openstack.block_storage.v3.group.Group> instance.
list_volume — whether to include the IDs of the volumes that are members of the group in the response. Requires microversion 3.25 or later. ⚠️ so if you're on an older microversion, no volume IDs for you.
attrs — DEPRECATED optional query parameters to be sent to limit the resources being returned. Yeah she's deprecated, we don't stan her anymore. 💀

Returns

A Group instance.

find_group(name_or_id, ignore_missing=True, *, details=True) — finds you a single group, no matter how hard they're hiding. 🕵️

Parameters

name_or_id — the name or ID of a group.
ignore_missing — when set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the group snapshot does not exist.
details — when set to False, no additional details will be returned. The default, True, will cause additional details to be returned.

Returns

One Group <#openstack.block_storage.v3.group.Group>

Raises NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found.

Raises DuplicateResource <#openstack.exceptions.DuplicateResource> when multiple resources are found. 😭 yes, two groups with the same name is a whole situation.

groups(*, details=True, **query) — retrieves a generator of groups. Group chat energy but for storage. 🫶

Parameters

details — when set to False, no additional details will be returned. The default, True, will cause additional details to be returned.
query —

Optional query parameters to be sent to limit the resources being returned:

all_tenants: Shows details for all project.
sort: Comma-separated list of sort keys and optional sort directions.
limit: Returns a number of items up to the limit value.
offset: Used in conjunction with limit to return a slice of items. Specifies where to start in the list.
marker: The ID of the last-seen item.
list_volume: Show volume ids in this group.
detailed: If True, will list groups with details.
search_opts: Search options.

Returns

A generator of group objects.

create_group(**attrs) — creates a brand new group from attributes. New group, who dis? ✨

Parameters

attrs — keyword arguments which will be used to create a Group <#openstack.block_storage.v3.group.Group> comprised of the properties on the Group class.

Returns

The results of group creation.

create_group_from_source(**attrs) — creates a new group from a source. It's giving "inspired by, but make it new." 🦋

Parameters

attrs — keyword arguments which will be used to create a Group <#openstack.block_storage.v3.group.Group> comprised of the properties on the Group class.

Returns

The results of group creation.

delete_group(group, delete_volumes=False, ignore_missing=True) — deletes a group. Bye bestie, don't let the door hit you. 💅

Parameters

group — the Group <#openstack.block_storage.v3.group.Group> to delete.
delete_volumes — when set to True, volumes in group will be deleted. 🚨 yes, the volumes too, so like, be sure before you flip this one.
ignore_missing — when set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the group does not exist. When set to True, no exception will be set when attempting to delete a nonexistent group.

Returns

None.

update_group(group, **attrs) — updates a group. Glow-up arc, activated. 🔥

Parameters

group — the value can be the ID of a group or a Group <#openstack.block_storage.v3.group.Group> instance.
attrs — the attributes to update on the group.

Returns

The updated group

`reset_group_status(group, status)` ✨

Reset group status — okay so this one literally resets the status of a group. No cap.

group — the Group <#openstack.block_storage.v3.group.Group> to set the state.
status — the status for a group.

Returns: None — it’s giving minimal effort but in a cool way 💅

`enable_group_replication(group)` 🦋

Enable replication for a group — bestie, this turns replication ON for that group.

group — the Group <#openstack.block_storage.v3.group.Group> to enable replication for.

Returns: None

`disable_group_replication(group)` 🎀

Disable replication for a group — the opposite vibe, turns replication OFF.

group — the Group <#openstack.block_storage.v3.group.Group> to disable replication for.

Returns: None

`failover_group_replication(group, *, allowed_attached_volume=False, secondary_backend_id=None)` 🔥

Failover replication for a group — dramatic failover moment, but make it secure.

group — the Group <#openstack.block_storage.v3.group.Group> to failover replication for.
allowed_attached_volume — whether to allow attached volumes in the group. Defaults to False.
secondary_backend_id — the secondary backend ID. Defaults to None.

Returns: None

✨ Group Snapshot Operations ✨

class openstack.block_storage.v3._proxy.Proxy(session, *,
service_type=None, service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

`get_group_snapshot(group_snapshot)` 🌸

Get a group snapshot — pull up one snack, I mean snapshot.

group_snapshot — the value can be the ID of a group snapshot or a GroupSnapshot <#openstack.block_storage.v3.group_snapshot.GroupSnapshot> instance.

Returns: A GroupSnapshot instance.

`find_group_snapshot(name_or_id, ignore_missing=True, *, details=True)` 🫶

Find a single group snapshot — like a search party but for snapshots.

name_or_id — the name or ID of a group snapshot.
ignore_missing — when set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the group snapshot does not exist.
details — when set to False, no additional details will be returned. The default, True, will cause additional details to be returned.

Returns: One group_snapshot <#module-openstack.block_storage.v3.group_snapshot>

Raises: NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found.

Raises: DuplicateResource <#openstack.exceptions.DuplicateResource> when multiple resources are found.

`group_snapshots(*, details=True, **query)` 🌈

Retrieve a generator of group snapshots — it’s giving infinite scroll energy.

details — when True, returns GroupSnapshot <#openstack.block_storage.v3.group_snapshot.GroupSnapshot> objects with additional attributes filled.
query — optional query parameters to be sent to limit the group snapshots being returned.

Returns: A generator of group snapshtos. (yes, that’s the typo in the original, keep it 💀)

`create_group_snapshot(**attrs)` ⭐

Create a group snapshot — new snapshot, who dis?

attrs — keyword arguments which will be used to create a GroupSnapshot <#openstack.block_storage.v3.group_snapshot.GroupSnapshot> comprised of the properties on the GroupSnapshot class.

Returns: The results of group snapshot creation.

`reset_group_snapshot_status(group_snapshot, status)` 💜

Reset group snapshot status — reset button but make it snapshots.

group_snapshot — the GroupSnapshot <#openstack.block_storage.v3.group_snapshot.GroupSnapshot> to set the state.
state — the status of the group snapshot to be set.

Returns: None

⚠️ heads up: the parameter in the signature is status but the description says state. We’re just the messenger, bestie.

`delete_group_snapshot(group_snapshot, ignore_missing=True)` 🍓

Delete a group snapshot — bye-bye snapshot.

group_snapshot — the GroupSnapshot to delete.
ignore_missing — when set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the group snapshot does not exist. When set to True, no exception will be set when attempting to delete a nonexistent group snapshot.

Returns: None

👑 Group Type Operations 👑

class openstack.block_storage.v3._proxy.Proxy(session, *,
service_type=None, service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

`get_group_type(group_type)` 🎀

Get a specific group type — one group type, coming right up.

group_type — the value can be the ID of a group type or a GroupType <#openstack.block_storage.v3.group_type.GroupType> instance.

Returns: One :class: ~openstack.block_storage.v3.group_type.GroupType instance.

Raises: NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found.

`find_group_type(name_or_id, ignore_missing=True)` 🧚

Find a single group type — detective mode activated.

name_or_id — the name or ID of a group type.
ignore_missing — when set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the group type does not exist.

Returns: One GroupType <#openstack.block_storage.v3.group_type.GroupType>

Raises: NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found.

Raises: DuplicateResource <#openstack.exceptions.DuplicateResource> when multiple resources are found.

`group_types(**query)` 🌟

Retrieve a generator of group types — a whole vibe of group types.

query — optional query parameters to be sent to limit the resources being returned:
- sort: Comma-separated list of sort keys and optional sort directions in the form of <key> [:<direction>]. A valid direction is asc (ascending) or desc (descending).
- limit: Requests a page size of items. Returns a number of items up to a limit value. Use the limit parameter to make an initial limited request and use the ID of the last-seen item from the response as the marker parameter value in a subsequent limited request.
- offset: Used in conjunction with limit to return a slice of items. Is where to start in the list.
- marker: The ID of the last-seen item.

Returns: A generator of group type objects.

`create_group_type(**attrs)` 💖

Create a group type — birth of a group type, iconic.

attrs — keyword arguments which will be used to create a GroupType <#openstack.block_storage.v3.group_type.GroupType> comprised of the properties on the GroupType class.

Returns: The results of group type creation.

`delete_group_type(group_type, ignore_missing=True)` 💀

Delete a group type — yeet that group type.

group_type — the value can be the ID of a group type or a GroupType <#openstack.block_storage.v3.group_type.GroupType> instance.
ignore_missing — when set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the zone does not exist. When set to True, no exception will be set when attempting to delete a nonexistent zone.

Returns: None

🫠 note: the original says “zone” here, not “group type” — we’re keeping it exactly as written, no cap.

`update_group_type(group_type, **attrs)`

Update a group_type

Parameters

group_type — The value can be the ID of a group type or a GroupType (openstack.block_storage.v3.group_type.GroupType) instance. 💅
attrs — The attributes to update on the group type.

Returns — The updated group type. ✨

fetch_group_type_group_specs(group_type) — Lists group specs of a group type. 🦋

Parameters
- group_type — Either the ID of a group type or a GroupType (openstack.block_storage.v3.group_type.GroupType) instance.
Returns — One GroupType (openstack.block_storage.v3.group_type.GroupType). 💖

create_group_type_group_specs(group_type, group_specs) — Create group specs for a group type. 🎀

Parameters
- group_type — Either the ID of a group type or a GroupType (openstack.block_storage.v3.group_type.GroupType) instance.
- group_specs — dict of extra specs.
Returns — One GroupType (openstack.block_storage.v3.group_type.GroupType). ✨

get_group_type_group_specs_property(group_type, prop) — Retrieve a group spec property for a group type. 🔍

Parameters
- group_type — Either the ID of a group type or a GroupType (openstack.block_storage.v3.group_type.GroupType) instance.
- prop — Property name.
Returns — String value of the requested property. 💜

update_group_type_group_specs_property(group_type, prop, val) — Update a group spec property for a group type. 🛠️

Parameters
- group_type — Either the ID of a group type or a GroupType (openstack.block_storage.v3.group_type.GroupType) instance.
- prop — Property name.
- val — Property value.
Returns — String value of the requested property. ⭐

delete_group_type_group_specs_property(group_type, prop, ignore_missing=True) — Delete a group spec property from a group type. 🧚

Parameters
- group_type — Either the ID of a group type or a GroupType (openstack.block_storage.v3.group_type.GroupType) instance.
- prop — Property name.
- ignore_missing — When set to False, NotFoundException (openstack.exceptions.NotFoundException) will be raised when the group type or group spec does not exist. When set to True, no exception will be set when attempting to delete a nonexistent group type group spec.
Returns — None. 😭

💬 Message Operations 💬

class openstack.block_storage.v3._proxy.Proxy(session, *,
service_type=None, service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

get_message(message) — Get a message. 📨

Parameters
- message — The value can be the ID of a message or a Message (openstack.block_storage.v3.message.Message) instance.
Returns — Message instance. 💌

delete_message(message, ignore_missing=True) — Delete a message. 🗑️

Parameters
- message — The value can be either the ID of a message or a Message instance.
- ignore_missing — When set to False, ResourceNotFound (openstack.exceptions.ResourceNotFound) will be raised when the message does not exist. When set to True, no exception will be set when attempting to delete a nonexistent message.
Returns — None. 💀

messages(**query) — Retrieve a generator of messages. 🌈

Returns — A generator of message objects. ✨

👑 QuotaClassSet Operations 👑

class openstack.block_storage.v3._proxy.Proxy(session, *,
service_type=None, service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

get_quota_class_set(quota_class_set='default') — Get a single quota class set. 🎀

Only one quota class is permitted, default. Periodt. 💅

Parameters
- quota_class_set — The value can be the ID of a quota class set (only default is supported) or a QuotaClassSet (openstack.block_storage.v3.quota_class_set.QuotaClassSet) instance.
Returns — One QuotaClassSet (openstack.block_storage.v3.quota_class_set.QuotaClassSet). 💖
Raises — NotFoundException (openstack.exceptions.NotFoundException) when no resource can be found. 😭

update_quota_class_set(quota_class_set, **attrs) — Update a QuotaClassSet. 🛠️

Only one quota class is permitted, default. Fr fr. 🌸

Parameters
- quota_class_set — Either the ID of a quota class set (only default is supported) or a
- attrs — The attributes to update on the QuotaClassSet represented by quota_class_set.
Returns — The updated QuotaSet. ⭐

🍓 QuotaSet Operations 🍓

class openstack.block_storage.v3._proxy.Proxy(session, *,
service_type=None, service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

get_quota_set(project, usage=False, **query) — Show QuotaSet information for the project. 📊

Parameters
- project — ID or instance of Project of the project for which the quota should be retrieved.
- usage — When set to True, quota usage and reservations would be filled. 👀
- query — Additional query parameters to use.
Returns — One QuotaSet (openstack.block_storage.v3.quota_set.QuotaSet). 💜
Raises — NotFoundException (openstack.exceptions.NotFoundException) when no resource can be found. 😭

get_quota_set_defaults(project) — Show QuotaSet defaults for the project. 🌟

Parameters
- project — ID or instance of Project of the project for which the quota should be retrieved.
Returns — One QuotaSet (openstack.block_storage.v3.quota_set.QuotaSet). 💖
Raises — NotFoundException (openstack.exceptions.NotFoundException) when no resource can be found. 💀

revert_quota_set(project, **query) — Reset quota for the project/user. 🔄

Parameters
- project — ID or instance of Project of the project for which the quota should be resetted. (Yes, "resetted" — we don't make the rules. 🙈)
- query — Additional parameters to be used.
Returns — None. ✨

update_quota_set(project, **attrs) — Update a QuotaSet. 🛠️

Parameters
- project — ID or instance of Project of the project for which the quota should be reset.
- attrs — The attributes to update on the QuotaSet represented by quota_set.
Returns — The updated QuotaSet. 👑

💅 QoSSpec Operations

Okay bestie, this is the QoS spec corner of the block storage v3 proxy and it's honestly kind of a whole vibe. All of these live on the same class, and that class is a bit of a mouthful, so here's her full signature in all her glory — every kwarg, no cap 🫶:

class openstack.block_storage.v3._proxy.Proxy(session, *,
service_type=None, service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

🌸 `create_qos_spec(**attrs)`

Make a brand new QoS Spec out of attributes, like a little QoS baby ✨

Parameters

attrs — keyword arguments that get used to create a QoSSpec <#openstack.block_storage.v2.qos_spec.QoSSpec>, made up of the properties on the QoSSpec class.

Returns

The results of a QoS spec creation 🎀

🦋 `delete_qos_spec(qos_spec, ignore_missing=True, *, force=False)`

Delete a QoS Spec. Yes, gone. Bye 💅

Parameters

qos_spec — the value can be either the ID of a QoS spec or a QoSSpec <#openstack.block_storage.v2.qos_spec.QoSSpec> instance.
ignore_missing — when set to False, ResourceNotFound <#openstack.exceptions.ResourceNotFound> will be raised when the type does not exist. When set to True, no exception will be set when attempting to delete a nonexistent type.
force — whether to delete the QoS spec even if it's in use.

⚠️ That force flag is giving "I know what I'm doing" energy — it nukes the spec even if it's in use. Respect the power, bestie.

Returns

None

🧚 `update_qos_spec(qos_spec, **attrs)`

Update a QoS spec — glow-up time 🔥

Parameters

qos_spec — the value can be either the ID of a QoS spec or a QoSSpec <#openstack.block_storage.v2.qos_spec.QoSSpec> instance.
attrs — the attributes to update on the QoS spec.

Returns

The updated QoS spec 👑

⭐ `get_qos_spec(qos_spec)`

Grab a single QoS spec, main character only 💖

Parameters

qos_spec — the value can be either the ID of a QoS spec or a QoSSpec <#openstack.block_storage.v2.qos_spec.QoSSpec> instance.

Returns

One QoSSpec <#openstack.block_storage.v2.qos_spec.QoSSpec>

Raises ResourceNotFound <#openstack.exceptions.ResourceNotFound> when no resource can be found.

🌈 `find_qos_spec(name_or_id, ignore_missing=True, **query)`

Find a single QoS spec — the scavenger hunt version 🔍

Parameters

name_or_id — the name or ID of a QoS spec.
ignore_missing — when set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the resource does not exist. When set to True, None will be returned when attempting to find a nonexistent resource.
query — additional attributes like 'host'.

Returns

One: class:~openstack.block_storage.v2.qos_spec.QoSSpec or None

Raises NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found.

Raises DuplicateResource <#openstack.exceptions.DuplicateResource> when multiple resources are found.

😭 Two matches and she panics — that's the DuplicateResource, not a personality flaw.

🍓 `qos_specs(**query)`

Return a generator of QoS specs, like a lil pipeline of them ✨

Parameters

query — optional query parameters to be sent to limit the resources being returned.

Returns

A generator of QoSSpec objects

💜 `associate_qos_spec(qos_spec, vol_type_id)`

Associate a QoS spec with a volume type. Matchmaker mode 🫶

Parameters

qos_spec — the value can be either the ID of a QoS spec or a QoSSpec <#openstack.block_storage.v3.qos_spec.QoSSpec> instance.
vol_type_id — the ID of the volume type to associate with.

Returns

None

💀 `disassociate_qos_spec(qos_spec, vol_type_id)`

Disassociate a QoS spec from a volume type. The breakup episode 😭

Parameters

qos_spec — the value can be either the ID of a QoS spec or a QoSSpec <#openstack.block_storage.v3.qos_spec.QoSSpec> instance.
vol_type_id — the ID of the volume type to disassociate from.

Returns

None

🌸 `disassociate_all_qos_spec(qos_spec)`

Disassociate a QoS spec from all volume types. Not a breakup, a whole era-ending 💅

Parameters

qos_spec — the value can be either the ID of a QoS spec or a QoSSpec <#openstack.block_storage.v3.qos_spec.QoSSpec> instance.

Returns

None

🎀 `delete_qos_spec_metadata(qos_spec, keys)`

Delete metadata from a QoS spec — spring cleaning 🔥

Parameters

qos_spec — the value can be either the ID of a QoS spec or a QoSSpec <#openstack.block_storage.v3.qos_spec.QoSSpec> instance.
keys — the keys to delete from the QoS spec.

Returns

None

🦋 `qos_spec_associations(qos_spec)`

Return a generator of associations for a QoS spec. Who's linked to who, the lore 🌈

Parameters

qos_spec — the value can be either the ID of a QoS spec or a QoSSpec <#openstack.block_storage.v3.qos_spec.QoSSpec> instance.

Returns

A generator of QoSSpecAssociation <#openstack.block_storage.v3.qos_spec.QoSSpecAssociation> objects

🌟 Resource Filter Operations

Same class, same iconique signature, zero changes — here she is again for the record 💖:

class openstack.block_storage.v3._proxy.Proxy(session, *,
service_type=None, service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

✨ `resource_filters(**query)`

Retrieve a generator of resource filters. It's giving "quietly useful" 🎀

Returns

A generator of resource filters.

👑 Service Operations

And one more time — the exact same Proxy signature, because she's nothing if not consistent 🫶:

class openstack.block_storage.v3._proxy.Proxy(session, *,
service_type=None, service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

🔍 `find_service(name_or_id, ignore_missing=True, **query)`

Find a single service — detective era 🌸

Parameters

name_or_id — the name or ID of a service.
ignore_missing — when set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the resource does not exist. When set to True, None will be returned when attempting to find a nonexistent resource.
query — additional attributes like 'host'.

Returns

One: class:~openstack.block_storage.v3.service.Service or None

Raises NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found.

Raises DuplicateResource <#openstack.exceptions.DuplicateResource> when multiple resources are found.

🎀 `services(**query)`

Return a generator of service 🧚

Parameters

query — optional query parameters to be sent to limit the resources being returned.

Returns

A generator of Service objects

🌈 `enable_service(service)`

Enable a service. Turning it back on, we love a comeback 💖

Parameters

service — either the ID of a service or a Service <#openstack.block_storage.v3.service.Service> instance.

Returns

Updated service instance

💅 `disable_service(service, *, reason=None)`

Disable a service. Sit down for a sec, bestie ✨

Parameters

service — either the ID of a service or a Service <#openstack.block_storage.v3.service.Service> instance
reason — the reason to disable a service

Returns

Updated service instance

🔥 `thaw_service(service)`

Thaw a service

service — either the ID of a service, or an actual Service instance (openstack.block_storage.v3.service.Service) 🫶

Returns — the updated service instance, fresh and glowed-up ✨

`freeze_service(service)`

Okay so this one freezes a service 🧊 Like, it just puts it on pause, bestie.

service — either the ID of a service, or a Service instance (openstack.block_storage.v3.service.Service)

Returns — the updated service instance 💅

`set_service_log_levels(*, level, binary=None, server=None, prefix=None)`

Set the log level for services 🔥 Very main character of you.

Parameters

level — the log level to set, case insensitive, and the accepted values are INFO, WARNING, ERROR and DEBUG. No inventing your own levels, ngl 💀
binary — the binary name of the service.
server — the name of the host.
prefix — the prefix for the log path we're querying, for example cinder. or sqlalchemy.engine.. When it's not present, or when the empty string is passed, all log levels will be retrieved 🎀

Returns — None. That's it. That's the whole return 💜

`get_service_log_levels(*, binary=None, server=None, prefix=None)`

Get the log level for services 👑

Parameters

binary — the binary name of the service.
server — the name of the host.
prefix — the prefix for the log path we're querying, for example cinder. or sqlalchemy.engine.. When it's not present, or when the empty string is passed, all log levels will be retrieved 🌸

Returns — a generator of LogLevel objects. It's giving lazy-evaluation realness ✨

`failover_service(service, *, cluster=None, backend_id=None)`

Failover a service 🦋

Heads up bestie — this only applies to replicating cinder-volume services 💅 Like, don't try it on anything else, fr fr.

Parameters

service — either the ID of a service, or a Service instance (openstack.block_storage.v3.service.Service)

Returns — the updated service instance 🌈

`cleanup_service_workers(**attrs)`

Request a cleanup of services, with optional filtering 🧹

Parameters

attrs — the attributes used to filter services.

Returns — the results of the cleanup request 💖

🎀 Snapshot Operations 🎀

class openstack.block_storage.v3._proxy.Proxy(session, *,
service_type=None, service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

Look at that constructor. Iconic. No notes. 😭

`get_snapshot(snapshot)`

Get a single snapshot 📸

Parameters

snapshot — the value can be the ID of a snapshot, or a Snapshot instance (openstack.block_storage.v3.snapshot.Snapshot).

Returns — one Snapshot (openstack.block_storage.v3.snapshot.Snapshot) 💖

Raises — NotFoundException (openstack.exceptions.NotFoundException) when no resource can be found. Sad times 😭

`find_snapshot(name_or_id, ignore_missing=True, *, details=True, all_projects=False)`

Find a single snapshot 🔍 Like a scavenger hunt but for storage.

Parameters

snapshot — the name or ID of a snapshot.
ignore_missing — when set to False, NotFoundException (openstack.exceptions.NotFoundException) will be raised when the snapshot does not exist. When set to True, None will be returned when attempting to find a nonexistent resource. So basically, True = no drama 🫶
details — when set to False, ~openstack.block_storage.v3.snapshot.Snapshot objects will be returned. The default, True, will cause more attributes to be returned. More is more, bestie ✨
all_projects — when set to True, search for a snapshot by name across all projects. Note that this will likely result in a higher chance of duplicates. Admin-only by default 👑

Returns — one Snapshot (openstack.block_storage.v3.snapshot.Snapshot) 🌸

Raises — NotFoundException (openstack.exceptions.NotFoundException) when no resource can be found.

Raises — DuplicateResource (openstack.exceptions.DuplicateResource) when multiple resources are found. Oops, more than one match 🙈

`snapshots(*, details=True, all_projects=False, **query)`

Retrieve a generator of snapshots 🌈

Parameters

details — when set to False, ~openstack.block_storage.v3.snapshot.Snapshot objects will be returned. The default, True, will cause more attributes to be returned.
all_projects — when set to True, list snapshots from all projects. Admin-only by default 💅
query — optional query parameters to be sent to limit the snapshots being returned. Available parameters include:
- name: name of the snapshot as a string.
- project_id: filter the snapshots by project.
- volume_id: volume id of a snapshot.
- status: value of the status of the snapshot, so that you can filter on "available" for example 🔥

Returns — a generator of snapshot objects. Lazy loading, we love to see it 💜

`create_snapshot(**attrs)`

Create a new snapshot from attributes 🎀

Parameters

attrs — keyword arguments which will be used to create a Snapshot (openstack.block_storage.v3.snapshot.Snapshot), comprised of the properties on the Snapshot class.

Returns — the results of snapshot creation ✨

`update_snapshot(snapshot, **attrs)`

Update a snapshot 🦋

Parameters

snapshot — either the ID of a snapshot, or a Snapshot instance (openstack.block_storage.v3.snapshot.Snapshot).
attrs — the attributes to update on the snapshot.

Returns — the updated snapshot 💖

`delete_snapshot(snapshot, ignore_missing=True, force=False)`

Delete a snapshot 💀 Gone. Poof.

Parameters

snapshot — the value can be either the ID of a snapshot, or a Snapshot instance (openstack.block_storage.v3.snapshot.Snapshot).
ignore_missing — when set to False, NotFoundException (openstack.exceptions.NotFoundException) will be raised when the snapshot does not exist. When set to True, no exception will be set when attempting to delete a nonexistent snapshot. Chill mode activated 😌
force — whether to try forcing snapshot deletion. Use with care, bestie ⚠️

Returns — None

`fetch_snapshot_metadata(snapshot)`

Return a dictionary of metadata for a snapshot 📚

Parameters

snapshot — either the ID of a snapshot, or a Snapshot (openstack.block_storage.v3.snapshot.Snapshot).

Returns — a Snapshot (openstack.block_storage.v3.snapshot.Snapshot) with the snapshot's metadata. All keys and values are Unicode text 🌸

`get_snapshot_metadata(snapshot)`

Return a dictionary of metadata for a snapshot 📖

Deprecated since version 4.14.0: use fetch_snapshot_metadata() instead. Like, it's still here, but it's giving old money. Move on bestie 💅

`set_snapshot_metadata(snapshot, **metadata)`

Update metadata for a snapshot ✍️

Parameters

snapshot — either the ID of a snapshot, or a Snapshot (openstack.block_storage.v3.snapshot.Snapshot).
metadata — key/value pairs to be updated in the snapshot's metadata. No other metadata is modified by this call. All keys and values are stored as Unicode. Surgical precision, we stan 🔥

Returns — a Snapshot (openstack.block_storage.v3.snapshot.Snapshot) with the snapshot's metadata. All keys and values are Unicode text 💜

`delete_snapshot_metadata(snapshot, keys=None)`

Delete metadata for a snapshot 🧹

Parameters

snapshot — either the ID of a snapshot, or a Snapshot (openstack.block_storage.v3.snapshot.Snapshot).
keys — the keys to delete. If omitted, all metadata is removed. Yeah, all of it. Be sure, bestie 😭

Returns — None

`reset_snapshot_status(snapshot, status)`

Reset the status of the snapshot 🔄

Parameters

so we're still on the last function's params, and then it's a whole buffet of snapshot, transfer, and type methods. buckle up bestie 🎀

snapshot -- The value can be either the ID of a backup or a Snapshot <#openstack.block_storage.v3.snapshot.Snapshot> instance.
status -- New snapshot status

Returns: None

`set_snapshot_status(snapshot, status, progress=None)`

Update fields related to the status of a snapshot. 💅

Parameters:

snapshot -- The value can be either the ID of a backup or a Snapshot <#openstack.block_storage.v3.snapshot.Snapshot> instance.
status -- New snapshot status
progress -- A percentage value for snapshot build progress.

Returns: None

`manage_snapshot(**attrs)`

Creates a snapshot by using existing storage rather than allocating new storage. ✨

Parameters:

attrs -- Keyword arguments which will be used to create a Snapshot <#openstack.block_storage.v3.snapshot.Snapshot>, comprised of the properties on the Snapshot class.

Returns: The results of snapshot creation

`unmanage_snapshot(snapshot)`

Unmanage a snapshot from block storage provisioning. 🦋

Parameters:

snapshot -- Either the ID of a snapshot or a Snapshot <#openstack.block_storage.v3.snapshot.Snapshot>.

Returns: None

`manageable_snapshots(*, details=False, **query)`

List snapshots available for management on a host or cluster. 🔥

Parameters:

details -- When set to True, additional fields will be returned. The default, False, returns basic information.
query -- Optional query parameters to limit the resources returned:
- host: The Cinder host on which to list manageable snapshots.
- cluster: The Cinder cluster on which to list manageable snapshots. (requires microversion 3.17 or later)
- marker: Begin returning snapshots appearing later in the list than the snapshot represented by this reference.
- limit: Maximum number of snapshots to return.
- offset: Number of snapshots to skip after the marker.
- sort: Comma-separated list of sort keys and directions.

Returns: A generator of manageable snapshot objects.

Stats Operations

Here's the class signature, same as always but we gotta include it because details matter: 👑

class openstack.block_storage.v3._proxy.Proxy(session, *,
service_type=None, service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

`backend_pools(**query)`

Returns a generator of cinder Back-end storage pools. 🌈

Parameters:

query -- Optional query parameters to be sent to limit the resources being returned.

:returns A generator of cinder Back-end storage pools objects

Transfer Operations

Same class signature, no cap: 💯

class openstack.block_storage.v3._proxy.Proxy(session, *,
service_type=None, service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

`create_transfer(**attrs)`

Create a new Transfer record 🎀

Parameters:

volume_id -- The value is ID of the volume.
name -- The value is name of the transfer
attrs -- Keyword arguments which will be used to create a Transfer <#openstack.block_storage.v3.transfer.Transfer> comprised of the properties on the Transfer class.

Returns: The results of Transfer creation

`delete_transfer(transfer, ignore_missing=True)`

Delete a volume transfer 💀

Parameters:

transfer -- The value can be either the ID of a transfer or a Transfer instance.
ignore_missing -- When set to False NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the transfer does not exist. When set to True, no exception will be set when attempting to delete a nonexistent transfer.

Returns: None

`find_transfer(name_or_id, ignore_missing=True)`

Find a single transfer 🔍

Parameters:

name_or_id -- The name or ID a transfer
ignore_missing -- When set to False NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the volume transfer does not exist.

Returns: One Transfer <#openstack.block_storage.v3.transfer.Transfer>

Raises:

NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found.
DuplicateResource <#openstack.exceptions.DuplicateResource> when multiple resources are found.

`get_transfer(transfer)`

Get a single transfer 🫶

Parameters:

transfer -- The value can be the ID of a transfer or a Transfer <#openstack.block_storage.v3.transfer.Transfer> instance.

Returns: One Transfer <#openstack.block_storage.v3.transfer.Transfer>

Raises: NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found.

`transfers(*, details=True, all_projects=False, **query)`

Retrieve a generator of transfers 🌸

Parameters:

details -- When set to False no extended attributes will be returned. The default, True, will cause objects with additional attributes to be returned.
all_projects -- When set to True, list transfers from all projects. Admin-only by default.
query -- Optional query parameters to be sent to limit the transfers being returned.

Returns: A generator of transfer objects.

`accept_transfer(transfer, auth_key)`

Accept a Transfer 🤝

Parameters:

transfer -- The value can be the ID of a transfer or a Transfer <#openstack.block_storage.v3.transfer.Transfer> instance.
auth_key -- The key to authenticate volume transfer.

Returns: The results of Transfer creation

Type Operations

Again, the class signature. Obsessed with consistency. 💅

class openstack.block_storage.v3._proxy.Proxy(session, *,
service_type=None, service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

`get_type(type)`

Get a single type 🦋

Parameters:

type -- The value can be the ID of a type or a Type <#openstack.block_storage.v3.type.Type> instance.

Returns: One Type <#openstack.block_storage.v3.type.Type>

Raises: NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found.

`find_type(name_or_id, ignore_missing=True)`

Find a single volume type 🔎

Parameters:

snapshot -- The name or ID a volume type
ignore_missing -- When set to False NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the volume type does not exist.

Returns: One Type <#openstack.block_storage.v3.type.Type>

Raises: NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found.

get_type_encryption(volume_type) — grab the encryption deets of a volume type 💖 you pass volume_type as either the ID of a type or a Type instance. Returns one TypeEncryption. Raises NotFoundException when no resource can be found, so like… if it's not there, it's not there 😭
create_type_encryption(volume_type, **attrs) — spin up a brand-new type encryption from attributes ✨ volume_type is the ID of a type or a Type instance, and attrs are the keyword arguments used to create a TypeEncryption, made up of the properties on the TypeEncryption class. Returns the results of type encryption creation.
delete_type_encryption(encryption=None, volume_type=None, ignore_missing=True) — bye-bye type encryption attributes 🎀
- encryption — can be None or a TypeEncryption instance. If encryption is None then volume_type must be specified.
- volume_type — the ID of a type or a Type instance. Required if encryption is None.
- ignore_missing — when set to False, NotFoundException gets raised when the type does not exist. When set to True, no exception will be set when attempting to delete a nonexistent type.
- Returns None.
update_type_encryption(encryption=None, volume_type=None, **attrs) — update a type (yes the docs literally say "Update a type", we're not gonna fight it 💀)
- encryption — can be None or a TypeEncryption instance. If this is None then volume_type must be specified.
- volume_type — the ID of a type or a Type instance. Required if encryption is None.
- attrs — the attributes to update on the type encryption.
- Returns the updated type encryption.

🌈 Volume Operations 🌈

class openstack.block_storage.v3._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

get_volume(volume) — get a single volume 🦋 volume is either the ID of a volume or a Volume instance. Returns one Volume.

Raises NotFoundException when no resource can be found. She's not ghosting you, she's just not there 💀

find_volume(name_or_id, ignore_missing=True, *, details=True, all_projects=False) — find a single volume, the hunt is ON 👑
- snapshot — The name or ID a volume (yes bb, the manpage says snapshot here even though the argument is name_or_id — copying it exactly, no cap 🙈)
- ignore_missing — when set to False, NotFoundException will be raised when the volume does not exist.
- details — when set to False no extended attributes will be returned. The default, True, will cause objects with additional attributes to be returned.
- all_projects — when set to True, search for volume by name across all projects. Note that this will likely result in a higher chance of duplicates. Admin-only by default.

Returns one Volume.

Raises NotFoundException when no resource can be found.

Raises DuplicateResource when multiple resources are found — which is lowkey awk when it happens 😭

volumes(*, details=True, all_projects=False, **query) — retrieve a generator of volumes, a whole lil lineup ✨
- details — when set to False no extended attributes will be returned. The default, True, will cause objects with additional attributes to be returned.
- all_projects — when set to True, list volumes from all projects. Admin-only by default.
- query —

Optional query parameters to be sent to limit the volumes being returned — available parameters include:

name — name of the volume as a string.
status — value of the status of the volume so you can filter on "available", for example.

Returns — a generator of volume objects. Slay. ✨

`create_volume(**attrs)`

Create a new volume from attributes.

Parameters

attrs — keyword arguments which will be used to create a Volume, comprised of the properties on the Volume class.

Returns — the results of volume creation. 💖

`delete_volume(volume, ignore_missing=True, *, force=False, cascade=False)`

Delete a volume.

Parameters

volume — the value can be either the ID of a volume or a Volume instance.
ignore_missing — when set to False, NotFoundException will be raised when the volume does not exist. When set to True, no exception will be set when attempting to delete a nonexistent volume.
force — whether to try forcing volume deletion.
cascade — whether to remove any snapshots along with the volume.

Returns — None.

`update_volume(volume, **attrs)`

Update a volume.

Parameters

volume — either the ID of a volume or a Volume instance.
attrs — the attributes to update on the volume.

Returns — the updated volume. 🦋

`fetch_volume_metadata(volume)`

Return a dictionary of metadata for a volume.

Parameters

volume — either the ID of a volume or a Volume.

Returns — a Volume with the volume's metadata. All keys and values are Unicode text.

`get_volume_metadata(volume)`

Return a dictionary of metadata for a volume.

Deprecated since version 4.14.0: use fetch_volume_metadata() instead. No cap, use the newer one bestie. 💅

`set_volume_metadata(volume, **metadata)`

Update metadata for a volume.

Parameters

volume — either the ID of a volume or a Volume.
metadata — key/value pairs to be updated in the volume's metadata. No other metadata is modified by this call. All keys and values are stored as Unicode.

Returns — a Volume with the volume's metadata. All keys and values are Unicode text. 🎀

`delete_volume_metadata(volume, keys=None)`

Delete metadata for a volume.

Parameters

volume — either the ID of a volume or a Volume.
keys — the keys to delete. If omitted, all metadata is removed.

Returns — None.

`extend_volume(volume, size)`

Extend a volume.

Parameters

volume — the value can be either the ID of a volume or a Volume instance.
size — new volume size.

Returns — None.

`complete_volume_extend(volume, error=False)`

Complete a volume extend operation.

Parameters

volume — the value can be either the ID of a volume or a Volume instance.
error — used to indicate if an error has occurred that requires Cinder to roll back the extend operation.

Returns — None. 😭

`set_volume_readonly(volume, readonly=True)`

Set a volume's read-only flag.

Parameters

volume — the value can be either the ID of a volume or a Volume instance.
readonly — whether the volume should be a read-only volume or not.

Returns — None.

`retype_volume(volume, new_type, migration_policy='never')`

Retype the volume.

Parameters

volume — the value can be either the ID of a volume or a Volume instance.
new_type — the new volume type that volume is changed with. The value can be either the ID of the volume type or a Type instance.
migration_policy — specify if the volume should be migrated when it is re-typed. Possible values are on-demand or never. Default: never.

Returns — None. 🔥

`set_volume_bootable_status(volume, bootable)`

Set bootable status of the volume.

Parameters

volume — the value can be either the ID of a volume or a Volume instance.
bootable — specifies whether the volume should be bootable or not.

Returns — None.

`set_volume_image_metadata(volume, **metadata)`

Update image metadata for a volume.

Parameters

volume — either the ID of a volume or a Volume.
metadata — key/value pairs to be updated in the volume's image metadata. No other metadata is modified by this call.

Returns — None.

`delete_volume_image_metadata(volume, keys=None)`

Delete metadata for a volume.

Parameters

volume — either the ID of a volume or a Volume.
keys — the keys to delete. If omitted, all metadata is removed.

Returns — None. 🙈

`reset_volume_status(volume, status=None, attach_status=None, migration_status=None)`

Reset volume statuses.

Parameters

volume — the value can be either the ID of a volume or a Volume instance.
status — the new volume status.
attach_status — the new volume attach status.
migration_status — the new volume migration status (admin only).

Returns — None.

`revert_volume_to_snapshot(volume, snapshot)`

Revert a volume to its latest snapshot.

This method only support reverting a detached volume, and the volume status must be available. ⚠️

Parameters

volume — the value can be either the ID of a volume or a Volume instance.
snapshot — the value can be either the ID of a snapshot or a Snapshot instance.

Returns — None.

`attach_volume(volume, mountpoint, instance=None, host_name=None)`

Attaches a volume to a server.

Parameters

volume — the value can be either the ID of a volume or a Volume instance.
mountpoint — the attaching mount point.
instance — the UUID of the attaching instance.
host_name — the name of the attaching host.

Returns — None. 🫶

`detach_volume(volume, attachment, force=False, connector=None)`

Detaches a volume from a server.

Parameters

volume — the value can be either the ID of a volume or a Volume instance.
attachment — the ID of the attachment.
force — whether to force volume detach (rolls back an unsuccessful detach operation after you disconnect the volume).
connector — the connector object.

Returns — None.

`manage_volume(**attrs)`

Creates a volume by using existing storage rather than allocating new storage. 🌈

Parameters

attrs — the keyword arguments that get used to build a Volume, made up of all the properties on the Volume class.

Returns — the results of the volume creation 💖

`unmanage_volume(volume)`

Removes a volume from Block Storage management without removing the back-end storage object that's associated with it. like, it lets go of the leash but the dog is still fully there 🐕

Parameters

volume — can be either the ID of a volume or a Volume instance.

Returns — None

`manageable_volumes(*, details=False, **query)`

Lists the volumes that are available for management on a host or a cluster ✨

Parameters

details — when you set it to True, you get additional fields back. The default, False, just returns basic information.
query — optional query parameters to limit the resources returned:
- host: the Cinder host to list manageable volumes on.
- cluster: the Cinder cluster to list manageable volumes on. (requires microversion 3.17 or later)
- marker: begin returning volumes that appear later in the list than the volume represented by this reference.
- limit: maximum number of volumes to return.
- offset: number of volumes to skip after the marker.
- sort: comma-separated list of sort keys and directions.

Returns — a generator of manageable volume objects 🌸

`migrate_volume(volume, host=None, force_host_copy=False, lock_volume=False, cluster=None)`

Migrates a volume over to the host you specify 🦋

Parameters

volume — can be either the ID of a volume or a Volume instance.
host — the target host for the volume migration. Host format is <host@backend>.
force_host_copy — if it's false (the default), you rely on the volume backend driver to do the migration, which might be optimized. If it's true, or the volume driver fails to migrate the volume itself, a generic host-based migration gets performed instead.
lock_volume — if it's true, migrating an available volume will change its status to maintenance, which prevents other operations from being performed on the volume such as attach, detach, retype, etc.
cluster — the target cluster for the volume migration. Cluster format is <cluster@backend>. Starting with microversion 3.16, either cluster or host must be specified. If host is specified and is part of a cluster, the cluster is used as the target for the migration.

Returns — None

`complete_volume_migration(volume, new_volume, error=False)`

Wraps up the migration of a volume 🎀

Parameters

volume — can be either the ID of a volume or a Volume instance.
new_volume — the UUID of the new volume.
error — used to indicate whether an error happened somewhere else that now needs clean up.

Returns — None

`upload_volume_to_image(volume, image_name, force=False, disk_format=None, container_format=None, visibility=None, protected=None)`

Uploads the specified volume to the image service 📤

Parameters

volume — can be either the ID of a volume or a Volume instance.
image_name — the name for the new image.
force — enables or disables upload of a volume that's attached to an instance.
disk_format — disk format for the new image.
container_format — container format for the new image.
visibility — the visibility property of the new image.
protected — whether the new image is protected.

Returns — a dictionary describing the image 💅

`reserve_volume(volume)`

Marks a volume as reserved. consider it claimed, bestie 🔒

Parameters

volume — can be either the ID of a volume or a Volume instance.

Returns — None

`unreserve_volume(volume)`

Unmarks a volume as reserved. releasing it back into the wild 🕊️

Parameters

volume — can be either the ID of a volume or a Volume instance.

Returns — None

`begin_volume_detaching(volume)`

Updates the volume status to 'detaching' 🫶

Parameters

volume — can be either the ID of a volume or a Volume instance.

Returns — None

`abort_volume_detaching(volume)`

Updates the volume status to 'in-use' — nvm, we're staying attached 😭

Parameters

volume — can be either the ID of a volume or a Volume instance.

Returns — None

`init_volume_attachment(volume, connector)`

Initializes the volume attachment ✨

Parameters

volume — can be either the ID of a volume or a Volume instance.
connector — the connector object.

Returns — a dictionary containing the modified connector object

`terminate_volume_attachment(volume, connector)`

Updates the volume status to 'in-use' 💜

Parameters

volume — can be either the ID of a volume or a Volume instance.
connector — the connector object.

Returns — None

🫶 Helpers 🫶

ok so this is the actual proxy class, and it takes a lot of kwargs. like, a lot a lot. here's the whole signature verbatim, don't @ me:

class openstack.block_storage.v3._proxy.Proxy(session, *,
service_type=None, service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

`wait_for_status(res, status='available', failures=None, interval=2, wait=None, attribute='status', callback=None)`

Waits for the resource to land in a particular status. it's giving "are we there yet" but as a function ⏳

Parameters

session — the session to use for making this request.
resource — the resource to wait on to reach the status. The resource must have a status attribute specified via attribute.
status — desired status of the resource.
failures — statuses that would indicate the transition failed, such as 'ERROR'. Defaults to ['ERROR'].
interval — number of seconds to wait between checks.
wait — maximum number of seconds to wait for the transition. Set it to None to wait forever.
attribute — name of the resource attribute that contains the status.
callback — a callback function. This gets called with a single value, progress. It's API specific but is generally a percentage value from 0-100.

Returns — the updated resource.

Raises ResourceTimeout if the transition to status failed to occur within wait seconds. 😤

Raises ResourceFailure if the resource transitioned to one of the states in failures. 💀

Raises AttributeError if the resource does not have a status attribute. 🙈

`wait_for_delete(res, interval=2, wait=120, callback=None)`

Waits for a resource to be deleted. manifesting its absence 🦋

Parameters

res — the resource to wait on to be deleted.
interval — how many seconds to wait before two consecutive checks. ⏱️
wait — the maximum number of seconds to wait before the change. ⏳
callback — a callback function. It gets called with a single value, progress, which is a percentage value from 0-100. 📞

Returns The resource is returned on success. 💖

Raises ResourceTimeout <#openstack.exceptions.ResourceTimeout> if transition to delete failed to occur in the specified seconds. 😭

✨ Cluster API ✨

🫶 The Cluster Class 🫶

The cluster high-level interface is available through the cluster member of a Connection <#openstack.connection.Connection> object. The cluster member will only be added if the service is detected. 🔍

🛠️ Build Info Operations 🛠️

class openstack.clustering.v1._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

🌟 `get_build_info()` 🌟

Get build info for service engine and API. 🧚

Returns A dictionary containing the API and engine revision string. 📚

🦋 Profile Type Operations 🦋

class openstack.clustering.v1._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

💜 `profile_types(**query)` 💜

Get a generator of profile types. ✨

Returns A generator of objects that are of type ProfileType <#openstack.clustering.v1.profile_type.ProfileType>. 🎀

💜 `get_profile_type(profile_type)` 💜

Get the details about a profile type. 🔎

Parameters

profile_type — the name of the profile_type to retrieve, or an object of ProfileType <#openstack.clustering.v1.profile_type.ProfileType>. 🫶

Returns A ProfileType <#openstack.clustering.v1.profile_type.ProfileType> object. 🌸

Raises NotFoundException <#openstack.exceptions.NotFoundException> when no profile_type matching the name could be found. 💀

🌈 Profile Operations 🌈

class openstack.clustering.v1._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

🌟 `create_profile(**attrs)` 🌟

Create a new profile from attributes. 🛠️

Parameters

attrs — keyword arguments that will be used to create a Profile <#openstack.clustering.v1.profile.Profile>, it is comprised of the properties on the Profile class. 🧵

Returns The results of profile creation. 🎉

🌟 `delete_profile(profile, ignore_missing=True)` 🌟

Delete a profile. 🗑️

Parameters

profile — the value can be either the name or ID of a profile, or a Profile <#openstack.clustering.v1.profile.Profile> instance. 🫶
ignore_missing — when set to False, an exception NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the profile could not be found. When set to True, no exception will be raised when attempting to delete a non-existent profile. 🙈

Returns None 💅

🌟 `find_profile(name_or_id, ignore_missing=True)` 🌟

Find a single profile. 🔍

Parameters

name_or_id — the name or ID of a profile. 🏷️
ignore_missing — when set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the resource does not exist. When set to True, None will be returned when attempting to find a nonexistent resource. 🌙

Returns One Profile <#openstack.clustering.v1.profile.Profile> object or None. 🎀

🌟 `get_profile(profile)` 🌟

Get a single profile. ✨

Parameters

profile — the value can be the name or ID of a profile, or a Profile <#openstack.clustering.v1.profile.Profile> instance. 🫶

Returns One Profile <#openstack.clustering.v1.profile.Profile>. 💖

Raises NotFoundException <#openstack.exceptions.NotFoundException> when no profile matching the criteria could be found. 😭

🌟 `profiles(**query)` 🌟

Retrieve a generator of profiles. 🌊

Parameters

query — optional query parameters to be sent to restrict the profiles to be returned. Available parameters include:
- name: the name of a profile. 🏷️
- type: the type name of a profile. 🧚
- metadata: a list of key-value pairs that are associated with a profile. 🗂️
- sort: a list of sorting keys separated by commas. Each sorting key can optionally be attached with a sorting direction modifier which can be asc or desc. 🔀
- limit: requests a specified size of returned items from the query. Returns a number of items up to the specified limit value. 🔢
- marker: specifies the ID of the last-seen item. Use the limit parameter to make an initial limited request and use the ID of the last-seen item from the response as the marker parameter value in a subsequent limited request. 📍
- global_project: a boolean value indicating whether profiles from all projects will be returned. 🌍

Returns A generator of profile instances. 🦋

🌟 `update_profile(profile, **attrs)` 🌟

Update a profile. 🔧

Parameters

profile — either the name or the ID of the profile, or an instance of Profile <#openstack.clustering.v1.profile.Profile>. 🫶
attrs — the attributes to update on the profile represented by the value parameter. ✨

Returns The updated profile. 💅

🌟 `validate_profile(**attrs)` 🌟

Validate a profile spec. ✅

Parameters

attrs — keyword arguments that will be used to create a ProfileValidate, it is comprised of the properties on the Profile class. 🧵

Returns The results of profile validation. 🎀

👑 Policy Type Operations 👑

class openstack.clustering.v1._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

⭐ `policy_types(**query)` ⭐

Get a generator of policy types. 🌈

Returns A generator of objects that are of type PolicyType <#openstack.clustering.v1.policy_type.PolicyType>. 💖

⭐ `get_policy_type(policy_type)` ⭐

Get the details about a policy type. 🔎

Parameters

policy_type — the name of a poicy_type or an object of PolicyType <#openstack.clustering.v1.policy_type.PolicyType>. 🫶

Returns A PolicyType <#openstack.clustering.v1.policy_type.PolicyType> object. 🎀

Raises NotFoundException when no policy_type matching the name could be found. 😭 That's the whole mood — if it's not there, it's not there, and the SDK will respectfully tell you so.

✨ Policy Operations ✨

Okay bestie, deep breath, because the constructor on this one is long — but it's the same flavour of constructor every proxy in this file uses, so once you've read it once you've read it a hundred times. Here it is, character for character, no cap:

class openstack.clustering.v1._proxy.Proxy(session, *,
service_type=None, service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

Slay. Now the actual methods 💅

`create_policy(**attrs)`

Create a new policy from attributes. Fresh policy, brand new, main character energy ✨

Parameters

attrs — Keyword arguments that will be used to create a Policy, it is comprised of the properties on the Policy class.

Returns

The results of policy creation.

`delete_policy(policy, ignore_missing=True)`

Delete a policy. Bye bestie 🫶

Parameters

policy — The value can be either the name or ID of a policy or a Policy instance.
ignore_missing — When set to False, an exception NotFoundException will be raised when the policy could not be found. When set to True, no exception will be raised when attempting to delete a non-existent policy.

Returns

None

`find_policy(name_or_id, ignore_missing=True)`

Find a single policy. Just the one. One (1) policy, please 🙈

Parameters

name_or_id — The name or ID of a policy.
ignore_missing — When set to False NotFoundException will be raised when the specified policy does not exist. When set to True, None will be returned when attempting to find a nonexistent policy.

Returns

A policy object or None.

`get_policy(policy)`

Get a single policy. The way this one *fetches*… obsessed 💖

Parameters

policy — The value can be the name or ID of a policy or a Policy instance.

Returns

A policy object.

Raises NotFoundException when no policy matching the criteria could be found.

`policies(**query)`

Retrieve a generator of policies. Generator = it hands you items one at a time as you loop, so you're not waiting on the whole list to load. Iconic behaviour, honestly 🦋

Parameters

query — Optional query parameters to be sent to restrict the policies to be returned. Available parameters include:
- name: The name of a policy.
- type: The type name of a policy.
- sort: A list of sorting keys separated by commas. Each sorting key can optionally be attached with a sorting direction modifier which can be asc or desc.
- limit: Requests a specified size of returned items from the query. Returns a number of items up to the specified limit value.
- marker: Specifies the ID of the last-seen item. Use the limit parameter to make an initial limited request and use the ID of the last-seen item from the response as the marker parameter value in a subsequent limited request.
- global_project: A boolean value indicating whether policies from all projects will be returned.

Returns

A generator of policy instances.

`update_policy(policy, **attrs)`

Update a policy. Glow-up time 🔥

Parameters

policy — Either the name or the ID of a policy, or an instance of Policy.
attrs — The attributes to update on the policy represented by the value parameter.

Returns

The updated policy.

`validate_policy`

That's it. That's the whole entry. No parameters, no returns, no extra lore — literally just validate_policy sitting there being mysterious 💀 Don't @ me, that's what's in the source.

🎀 Cluster Operations 🎀

Same constructor, same vibes, different resource. Behold:

class openstack.clustering.v1._proxy.Proxy(session, *,
service_type=None, service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

`create_cluster(**attrs)`

Create a new cluster from attributes. New cluster just dropped 🌸

Parameters

attrs — Keyword arguments that will be used to create a Cluster, it is comprised of the properties on the Cluster class.

Returns

The results of cluster creation.

`delete_cluster(cluster, ignore_missing=True, force_delete=False)`

Delete a cluster. Note the extra flag here, bestie — that force_delete is doing heavy lifting 👑

Parameters

cluster — The value can be either the name or ID of a cluster or a Cluster instance.
ignore_missing — When set to False, an exception NotFoundException will be raised when the cluster could not be found. When set to True, no exception will be raised when attempting to delete a non-existent cluster.
force_delete — When set to True, the cluster deletion will be forced immediately.

Returns

The instance of the Cluster which was deleted.

⚠️ Heads up: force_delete forces the deletion immediately. That's not a gentle nudge, that's a yeet. Make sure that's actually what you want 💀

`find_cluster(name_or_id, ignore_missing=True)`

Find a single cluster. Sherlock mode 🔍

Parameters

name_or_id — The name or ID of a cluster.
ignore_missing — When set to False NotFoundException will be raised when the resource does not exist. When set to True, None will be returned when attempting to find a nonexistent resource.

Returns

One Cluster object or None

`get_cluster(cluster)`

Get a single cluster. Lowkey the simplest one here 💜

Parameters

cluster — The value can be the name or ID of a cluster or a Cluster instance.

Returns

One Cluster

Raises NotFoundException when no cluster matching the criteria could be found.

`clusters(**query)`

Retrieve a generator of clusters. Same generator deal as before — one at a time, no stress ✨

Parameters

query — Optional query parameters to be sent to restrict the clusters to be returned. Available parameters include:
- name: The name of a cluster.
- status: The current status of a cluster.
- sort: A list of sorting keys separated by commas. Each sorting key can optionally be attached with a sorting direction modifier which can be asc or desc.
- limit: Requests a specified size of returned items from the query. Returns a number of items up to the specified limit value.
- marker: Specifies the ID of the last-seen item. Use the limit parameter to make an initial limited request and use the ID of the last-seen item from the response as the marker parameter value in a subsequent limited request.
- global_project: A boolean value indicating whether clusters from all projects will be returned.

Returns

A generator of cluster instances.

`update_cluster(cluster, **attrs)`

Update a cluster. Give it a little refresh 💅

Parameters

cluster — Either the name or the ID of the cluster, or an instance of Cluster.
attrs — The attributes to update on the cluster represented by the cluster parameter.

Returns

The updated cluster.

`add_nodes_to_cluster(cluster, nodes)`

Add nodes to a cluster. Growing the squad 🌈

Parameters

nodes — the list of nodes you're adding in 🫶

Returns — a dict holding the action this operation kicked off. ✨

`remove_nodes_from_cluster(cluster, nodes, **params)`

Bye bestie 👋 — this one takes nodes out of a cluster.

Parameters

cluster — either the name or the ID of the cluster, or an instance of Cluster (openstack.clustering.v1.cluster.Cluster).
nodes — list of nodes to be removed from the cluster.
params — optional query parameters sent along to restrict the nodes to be returned. The available ones include:
- destroy_after_deletion: a boolean value indicating whether the deleted nodes get destroyed right away 💀

Returns — a dict containing the action initiated by this operation.

`replace_nodes_in_cluster(cluster, nodes)`

Swaps the nodes in a cluster out for the specified ones — out with the old, in with the new 🔁

Parameters

cluster — either the name or the ID of the cluster, or an instance of Cluster (openstack.clustering.v1.cluster.Cluster).
nodes — list of nodes to be deleted/added to the cluster.

Returns — a dict containing the action initiated by this operation.

`scale_out_cluster(cluster, count=None)`

Inflates the size of a cluster. Bigger. More. Go off 👑📈

Parameters

cluster — either the name or the ID of the cluster, or an instance of Cluster (openstack.clustering.v1.cluster.Cluster).
count — optional parameter specifying the number of nodes to be added.

Returns — a dict containing the action initiated by this operation.

`scale_in_cluster(cluster, count=None)`

Shrinks the size of a cluster. It's giving minimalism 🎀

Parameters

cluster — either the name or the ID of the cluster, or an instance of Cluster (openstack.clustering.v1.cluster.Cluster).
count — optional parameter specifying the number of nodes to be removed.

Returns — a dict containing the action initiated by this operation.

`resize_cluster(cluster, **params)`

Resize of cluster. Lowkey the glow-up button 🦋

Parameters

cluster — either the name or the ID of the cluster, or an instance of Cluster (openstack.clustering.v1.cluster.Cluster).
params — a dictionary providing the parameters for the resize action.

Returns — a dict containing the action initiated by this operation.

`attach_policy_to_cluster(cluster, policy, **params)`

Binds a policy onto a cluster. It's official now 💍

Parameters

cluster — either the name or the ID of the cluster, or an instance of Cluster (openstack.clustering.v1.cluster.Cluster).
policy — either the name or the ID of a policy.
params — a dictionary containing the properties for the policy to be attached.

Returns — a dict containing the action initiated by this operation.

`detach_policy_from_cluster(cluster, policy)`

Unbinds a policy from a cluster. We don't gatekeep 🫶

Parameters

cluster — either the name or the ID of the cluster, or an instance of Cluster (openstack.clustering.v1.cluster.Cluster).
policy — either the name or the ID of a policy.

Returns — a dict containing the action initiated by this operation.

`update_cluster_policy(cluster, policy, **attrs)`

Changes the properties of a policy that's bound to the cluster — a lil makeover for the policy ✨💅

Parameters

cluster — either the name or the ID of the cluster, or an instance of Cluster (openstack.clustering.v1.cluster.Cluster).
policy — either the name or the ID of a policy.
attrs — a dictionary containing the new properties for the policy.

Returns — a dict containing the action initiated by this operation.

`collect_cluster_attrs(cluster, path, **query)`

Collects attribute values across a whole cluster — like a vibe check but for attributes 🔍

Parameters

cluster — the value can be either the ID of a cluster or a Cluster (openstack.clustering.v1.cluster.Cluster) instance.
path — a Json path string specifying the attribute to collect.
query — optional query parameters to be sent to limit the resources being returned.

Returns — a dictionary containing the list of attribute values.

`check_cluster(cluster, **params)`

Checks a cluster. Wellness check time 🩺

Parameters

cluster — the value can be either the ID of a cluster or a Cluster (openstack.clustering.v1.cluster.Cluster) instance.
params — a dictionary providing the parameters for the check action.

Returns — a dictionary containing the action ID.

`recover_cluster(cluster, **params)`

recover a cluster. Healing era 🌈

Parameters

cluster — the value can be either the ID of a cluster or a Cluster (openstack.clustering.v1.cluster.Cluster) instance.
params — a dictionary providing the parameters for the recover action.

Returns — a dictionary containing the action ID.

`perform_operation_on_cluster(cluster, operation, **params)`

Performs an operation on the specified cluster — whatever operation you name, it does the thing 🔥

Parameters

cluster — the value can be either the ID of a cluster or a Cluster (openstack.clustering.v1.cluster.Cluster) instance.
operation — a string specifying the operation to be performed.
params — a dictionary providing the parameters for the operation.

Returns — a dictionary containing the action ID.

`cluster_policies(cluster, **query)`

Grabs you a generator of cluster-policy bindings — the whole roster, bestie 📋

Parameters

cluster — the value can be the name or ID of a cluster or a Cluster (openstack.clustering.v1.cluster.Cluster) instance.
query — optional query parameters to be sent to restrict the policies to be returned. The available ones include:
- enabled: a boolean value indicating whether the policy is enabled on the cluster.

Returns — a generator of cluster-policy binding instances.

`get_cluster_policy(cluster_policy, cluster)`

Gets one specific cluster-policy binding. The main character of bindings 👑

Parameters

cluster_policy — the value can be the name or ID of a policy or a Policy (openstack.clustering.v1.policy.Policy) instance.
cluster — the value can be the name or ID of a cluster or a Cluster (openstack.clustering.v1.cluster.Cluster) instance.

Returns — a cluster-policy binding object.

Raises — NotFoundException (openstack.exceptions.NotFoundException) when no cluster-policy binding matching the criteria could be found. 😭

🌸 Node Operations 🌸

Okay so real talk, this is the same Proxy class, just the node-flavoured half of it. Same constructor args, same everything, no cap:

class openstack.clustering.v1._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

`create_node(**attrs)`

Creates a brand-new node out of attributes. Birth of a node, iconic 🎀⭐

Parameters

attrs — keyword arguments that will be used to create a Node (openstack.clustering.v1.node.Node); it's comprised of the properties on the Node class.

Returns — the results of node creation.

`delete_node(node, ignore_missing=True, force_delete=False)`

Deletes a node.

node — literally just the name or ID of a node, or a whole Node instance, whichever you vibe with 🫶
ignore_missing — if you set this to False, an exception NotFoundException <#openstack.exceptions.NotFoundException> gets raised when the node can't be found. Set it to True and nobody panics when you try to delete a node that straight-up doesn't exist 💀
force_delete — set to True and the node deletion gets forced immediately, no waiting around ✨

Returns The instance of the Node which was deleted. Slay.

`find_node(name_or_id, ignore_missing=True)`

Find a single node. Just the one. Your main character node 👑

Parameters

name_or_id — the name or ID of a node.
ignore_missing — when set to "False", NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the specified node doesn't exist. When set to "True", None will be returned when attempting to find a nonexistent policy 🙈

Returns One Node <#openstack.clustering.v1.node.Node> object or None.

`get_node(node, details=False)`

Get a single node — lowkey the same energy as find_node but with a lil extra.

Parameters

node — the value can be the name or ID of a node or a Node <#openstack.clustering.v1.node.Node> instance.
details — an optional argument that says whether the server should return more details when retrieving the node data 👀

Returns One Node <#openstack.clustering.v1.node.Node>

Raises NotFoundException <#openstack.exceptions.NotFoundException> when no node matching the name or ID could be found. That's it, that's the vibe check.

`nodes(**query)`

Retrieve a generator of nodes. A whole generator, not a list — bestie's efficient like that 💅

Parameters

query — optional query parameters sent along to restrict which nodes come back. The available ones are:

cluster_id: a string including the name or ID of a cluster that the resulted node(s) is a member of.
name: the name of a node.
status: the current status of a node.
sort: a list of sorting keys separated by commas. Each sorting key can optionally be attached with a sorting direction modifier, which can be asc or desc.
limit: requests at most the specified number of items be returned from the query.
marker: specifies the ID of the last-seen node. Use the limit parameter to make an initial limited request, then use the ID of the last-seen node from the response as the marker parameter value in a subsequent limited request. Paging, but make it cute ✨
global_project: a boolean value indicating whether nodes from all projects will be returned.

Returns A generator of node instances. Obsessed.

`update_node(node, **attrs)`

Update a node. Glow-up time 💖

Parameters

node — either the name or the ID of the node, or an instance of Node <#openstack.clustering.v1.node.Node>.
attrs — the attributes to update on the node represented by the node parameter.

Returns The updated node. Iconic.

`check_node(node, **params)`

Check the health of the specified node. Doctor's appointment, but for infrastructure 🩺

Parameters

node — the value can be either the ID of a node or a Node <#openstack.clustering.v1.node.Node> instance.
params — a dictionary providing the parametes to the check action. (Yes, "parametes" — that's literally how the docs spell it, I'm not fixing it, character for character bestie 😭)

Returns A dictionary containing the action ID.

`recover_node(node, **params)`

Recover the specified node into healthy status. Healing arc 🌈

Parameters

node — the value can be either the ID of a node or a Node <#openstack.clustering.v1.node.Node> instance.
params — a dict supplying parameters to the recover action.

Returns A dictionary containing the action ID.

`adopt_node(preview=False, **attrs)`

Adopting an existing resource as a node. Found family trope, honestly 🫶

Parameters

preview — a boolean indicating whether this is a "preview" operation, which means only the profile to be used is returned rather than creating a node object using that profile.
attrs — keyword parameters for node adoption. Valid parameters include:
- type: (Required) a string containing the profile type and version to be used for node adoption. For example, os.nova.sever-1.0.
- identity: (Required) a string including the name or ID of an OpenStack resource to be adopted as a Senlin node.
- name: (Optional) the name of node to be created. Omitting this parameter will have the node named automatically.
- snapshot: (Optional) a boolean indicating whether a snapshot of the target resource should be created if possible. Default is False.
- metadata: (Optional) a dictionary of arbitrary key-value pairs to be associated with the adopted node.
- overrides: (Optional) a dictionary of key-value pairs to be used to override attributes derived from the target resource.

Returns The result of node adoption. If preview is set to False (default — that's the default btw), returns a Node <#openstack.clustering.v1.node.Node> object, otherwise a Dict is returned containing the profile to be used for the new node. Two different returns, iykyk 💫

`perform_operation_on_node(node, operation, **params)`

Perform an operation on the specified node. Whatever operation. Go off 💅

Parameters

node — the value can be either the ID of a node or a Node <#openstack.clustering.v1.node.Node> instance.
operation — a string specifying the operation to be performed.
params — a dictionary providing the parameters for the operation.

Returns A dictionary containing the action ID.

🎀 Receiver Operations 🎀

Here she is — the whole Proxy class, every single keyword arg, no skips, no cap 👑

class openstack.clustering.v1._proxy.Proxy(session, *,
service_type=None, service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

`create_receiver(**attrs)`

Create a new receiver from attributes. Fresh out the box 📦

Parameters

attrs — keyword arguments that will be used to create a Receiver <#openstack.clustering.v1.receiver.Receiver>. It's comprised of the properties on the Receiver class.

Returns The results of receiver creation. Ate.

`update_receiver(receiver, **attrs)`

Update a receiver.

Parameters

receiver — the value can be either the name or ID of a receiver or a Receiver <#openstack.clustering.v1.receiver.Receiver> instance.
attrs — the attributes to update on the receiver parameter. Valid attribute names include name, action and params.

Returns The updated receiver.

`delete_receiver(receiver, ignore_missing=True)`

Delete a receiver. Bye bestie 👋

Parameters

receiver — the value can be either the name or ID of a receiver or a Receiver <#openstack.clustering.v1.receiver.Receiver> instance.
ignore_missing — when set to False, an exception NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the receiver could not be found. When set to True, no exception will be raised when attempting to delete a non-existent receiver.

Returns None

`find_receiver(name_or_id, ignore_missing=True)`

Find a single receiver.

Parameters

name_or_id — the name or ID of a receiver.
ignore_missing — set this to False and boom, a NotFoundException <#openstack.exceptions.NotFoundException> gets raised the second the receiver you're looking for isn't there. Set it to True instead and you just get None back when it can't find a nonexistent receiver. ✨

Returns — a receiver object, or None. 🫶

`get_receiver(receiver)`

Get one (1) single receiver, bestie.

Parameters

receiver — this can be the name or the ID of a receiver, or you can straight up hand it a Receiver <#openstack.clustering.v1.receiver.Receiver> instance.

Returns — a receiver object. 💖

Raises NotFoundException <#openstack.exceptions.NotFoundException> when there's literally no receiver matching what you asked for. 😭

`receivers(**query)`

Retrieve a generator of receivers.

Parameters

query —

Optional query parameters for restricting which receivers come back. The available ones include:

name: the name of a receiver object.
type: the type of receiver objects.
cluster_id: the ID of the associated cluster.
action: the name of the associated action.
sort: a list of sorting keys separated by commas. Each sorting key can optionally be attached with a sorting direction modifier, which can be asc or desc.
global_project: a boolean value indicating whether receivers
from all projects will be returned.

Returns — a generator of receiver instances. 🌈

🔥 Action Operations 🔥

class openstack.clustering.v1._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

`get_action(action)`

Get a single action. Just the one. 💅

Parameters

action — the value can be the name or ID of an action, or a Action <#openstack.clustering.v1.action.Action> instance.

Returns — an action object. ⭐

Raises NotFoundException <#openstack.exceptions.NotFoundException> when no action matching the criteria could be found. 💀

`actions(**query)`

Retrieve a generator of actions.

Parameters

query —

Optional query parameters to be sent to restrict which actions come back. The available ones include:

name: name of action for query.
target: ID of the target object for which the actions should be returned.
action: built-in action types for query.
sort: a list of sorting keys separated by commas. Each sorting key can optionally be attached with a sorting direction modifier, which can be asc or desc.
limit: requests a specified size of returned items from the query. Returns a number of items up to the specified limit value.
marker: specifies the ID of the last-seen item. Use the limit parameter to make an initial limited request, then use the ID of the last-seen item from the response as the marker parameter value in a subsequent limited request. iykyk 🌀

Returns — a generator of action instances. 🦋

🌸 Event Operations 🌸

class openstack.clustering.v1._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

`get_event(event)`

Get a single event, no cap. 👑

Parameters

event — the value can be the name or ID of an event, or a Event <#openstack.clustering.v1.event.Event> instance.

Returns — an event object. 🎀

Raises NotFoundException <#openstack.exceptions.NotFoundException> when no event matching the criteria could be found. 🙈

`events(**query)`

Retrieve a generator of events.

Parameters

query —

Optional query parameters to be sent to restrict which events come back. The available ones include:

obj_name: name string of the object associated with an event.
obj_type: type string of the object related to an event. The value can be cluster, node, policy etc.
obj_id: ID of the object associated with an event.
cluster_id: ID of the cluster associated with the event, if any.
action: name of the action associated with an event.
sort: a list of sorting keys separated by commas. Each sorting key can optionally be attached with a sorting direction modifier, which can be asc or desc.
limit: requests a specified size of returned items from the query. Returns a number of items up to the specified limit value.
marker: specifies the ID of the last-seen item. Use the limit parameter to make an initial limited request, then use the ID of the last-seen item from the response as the marker parameter value in a subsequent limited request.
global_project: a boolean specifying whether events from all projects should be returned. Heads up bestie — this option is subject to access control checking. 🔐

Returns — a generator of event instances. ✨

🧚 Helper Operations 🧚

class openstack.clustering.v1._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

`wait_for_status(res, status, failures=None, interval=2, wait=None, attribute='status', callback=None)`

Wait for the resource to be in a particular status. It's giving "are we there yet" but make it infrastructure. 🚗💨

Parameters

session — the session to use for making this request.
resource — the resource to wait on to reach the status. The resource must have a status attribute specified via attribute.
status — desired status of the resource.
failures — statuses that would indicate the transition failed, such as 'ERROR'. Defaults to ['ERROR'].
interval — number of seconds to wait between checks.
wait — maximum number of seconds to wait for transition. Set to None to wait forever. 😳
attribute — name of the resource attribute that contains the status.
callback — a callback function. This will be called with a single value, progress. This is API specific but is generally a percentage value from 0-100. 📈

Returns — the updated resource. 💜

Raises ResourceTimeout <#openstack.exceptions.ResourceTimeout> if the transition to status failed to occur in wait seconds. ⏰

Raises ResourceFailure <#openstack.exceptions.ResourceFailure> if the resource transitioned to one of the states in failures. 💀

Raises AttributeError if the resource does not have a status attribute. 🫠

wait_for_delete(res, interval=2, wait=120, callback=None) — okay so this one just waits for a resource to be yeeted into the void. Patience is the vibe 💅

Parameters:

res — the resource you're waiting on to be deleted. like, "please be gone bestie" 🫶
interval — how many seconds to wait between two consecutive checks.
wait — the max number of seconds to wait before the change happens.
callback — a callback function 💖 it gets called with a single value, progress, which is a percentage value from 0-100.

Returns: the resource is returned on success, slay.

Raises ResourceTimeout <#openstack.exceptions.ResourceTimeout> if the transition to delete failed to occur in the specified seconds. so like, if the deletion ghosted you entirely 😭 set your wait higher, ngl.

🎀 Service Operations 🎀

class openstack.clustering.v1._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

services(**query) — get a generator of services. that's it, that's the whole function, main character energy 👑

Returns: a generator of objects that are of type Service.

💻 Compute API 💻

For the full tea on how to use compute, see Using OpenStack Compute <>. 🔥

🖥️ The Compute Class 🖥️

The compute high-level interface is available through the compute member of a Connection <#openstack.connection.Connection> object. Heads up though: the compute member only gets added if the service is actually detected. so if it's not there, it's not being shady, the service just isn't there bestie 🙈

🌸 Server Operations 🌸

class openstack.compute.v2._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

create_server(**attrs) — spin up a brand new server from attributes. iconique ✨

Parameters:

attrs — keyword arguments which will be used to create a Server <#openstack.compute.v2.server.Server>, comprised of the properties on the Server class.

Returns: the results of server creation 🎀

delete_server(server, ignore_missing=True, force=False) — delete a server. bye bestie 💀

Parameters:

server — the value can be either the ID of a server or a Server <#openstack.compute.v2.server.Server> instance.
ignore_missing — when set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the server does not exist. When set to True, no exception will be set when attempting to delete a nonexistent server.
force — when set to True, the server deletion will be forced immediately. like ripping off the bandaid 🔥

Returns: None

find_server(name_or_id, ignore_missing=True, *, details=True, all_projects=False) — find a single server. detective mode 🕵️‍♀️

Parameters:

name_or_id — the name or ID of a server.
ignore_missing — when set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the resource does not exist. When set to True, None will be returned when attempting to find a nonexistent resource.
details — when set to False, instances with only basic data will be returned. The default, True, will cause instances with full data to be returned.
all_projects — when set to True, search for server by name across all projects. Note that this will likely result in a higher chance of duplicates. Admin-only by default, so like, don't try it if you're not admin 💅

Returns: one Server <#openstack.compute.v2.server.Server> or None

Raises NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found.

Raises DuplicateResource <#openstack.exceptions.DuplicateResource> when multiple resources are found. (yup, that's the duplicate situation we literally just warned you about 😭)

get_server(server) — get a single server.

Parameters:

server — the value can be the ID of a server or a Server <#openstack.compute.v2.server.Server> instance.

Returns: one Server <#openstack.compute.v2.server.Server>

Raises NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found.

servers(details=True, all_projects=False, **query) — retrieve a generator of servers. all of them. every single one 🦋

Parameters:

details — when set to False, instances with only basic data will be returned. The default, True, will cause instances with full data to be returned.
all_projects — when set to True, lists servers from all projects. Admin-only by default.
query — optional query parameters to be sent to limit the servers being returned. available parameters can be seen under <https://docs.openstack.org/api-ref/compute/#list-servers> 👑

Returns: a generator of server instances.

update_server(server, **attrs) — update a server. glow-up time ✨

Parameters:

server — either the ID of a server or a Server <#openstack.compute.v2.server.Server> instance.
attrs — the attributes to update on the server represented by server.

Returns: the updated server.

create_server_image(server, name, metadata=None, wait=False, timeout=120) — create an image from a server. turning your server into a whole photoshoot 📸

Parameters:

server — either the ID of a server or a Server <#openstack.compute.v2.server.Server> instance.
name — the name of the image to be created.
metadata — a dictionary of metadata to be set on the image.

Returns: Image <#openstack.image.v2.image.Image> object.

backup_server(server, name, backup_type, rotation, *, wait=False, timeout=120) — backup a server. safety first, always 🫶

Parameters:

server — either the ID of a server or a Server <#openstack.compute.v2.server.Server> instance.
name — the name of the backup image.
backup_type — the type of the backup, for example, daily.
rotation — the rotation of the back up image, the oldest image will be removed when image count exceed the rotation count.
wait (bool) — if True, waits for image to reach active status before returning.
timeout (int) — the maximum number of seconds to wait for the image to become active when wait is True.

Returns: Image <#openstack.image.v2.image.Image> object.

get_server_metadata(server) — return a dictionary of metadata for a server.

Deprecated since version 4.14.0: use fetch_server_metadata() instead. like, it still works but it's giving legacy, ok? move on bestie 💀

set_server_metadata(server, **metadata) — update metadata for a server.

Parameters:

server — either the ID of a server or a Server <#openstack.compute.v2.server.Server> instance.
metadata — key/value pairs to be updated in the server's metadata. no other metadata is modified by this call. so it's surgical, not chaotic 💅

Returns: a Server <#openstack.compute.v2.server.Server> with only the server's metadata.

delete_server_metadata(server, keys=None) — delete metadata for a server.

Note: this method will do a HTTP DELETE request for every key in keys. like one request per key, fr fr, so don't hand it a hundred keys and then act surprised 😭

Parameters:

server — either the ID of a server or a Server <#openstack.compute.v2.server.Server> instance.
keys — the keys to delete. If omitted, all metadata is removed. all of it. gone. 🧹

Returns: None

wait_for_server(server, status='ACTIVE', failures=None, interval=2, wait=120, callback=None) — wait for a server to be in a particular status. the classic "is it up yet" moment 🌈

Parameters:

server (Server) — the actual Server you're waiting on to hit that status. Like, the whole point of the call 💅
status (str) — the status you want it to reach.
failures (list) — a list of statuses that count as an L, i.e. if the server lands on any of these, it's a fail.
interval (int) — how many seconds to wait between two consecutive checks. Defaults to 2.
wait — max number of seconds to wait before the change happens. Defaults to 120.
callback (callable) — a callback function. It gets called with a single value, progress, which is a percentage from 0-100. So cute for progress bars 🎀

Returns

The resource comes back to you on success. 🫶

Raises ResourceTimeout if the transition to the desired status didn't happen within the seconds you specified. Yeah, it gave up on you.

Raises ResourceFailure if the resource has transited into one of the failure statuses. Oop.

Raises AttributeError if the resource doesn't even have a status attribute. Not the resource being mysterious, just the resource being broken 😭

🌐 Network Actions 🌐

class openstack.compute.v2._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

`fetch_server_security_groups(server)`

Fetches the security groups for a server, with details. Bestie, the details are the whole point.

Parameters

server — either the ID of a server or a Server instance.

Returns

an updated Server instance. Slay.

`add_security_group_to_server(server, security_group)`

Adds a security group to a server. Giving it a lil outfit ✨

Parameters

server — either the ID of a server or a Server instance.
security_group — either the ID or name of a security group, or a SecurityGroup instance.

Returns

None

`remove_security_group_from_server(server, security_group)`

Removes a security group from a server. Taking the outfit back, no hard feelings 💅

Parameters

server — either the ID of a server or a Server instance.
security_group — either the ID or name of a security group, or a SecurityGroup instance.

Returns

None

`add_fixed_ip_to_server(server, network)`

Adds a fixed IP address to a server instance. A permanent little address, iconic.

Parameters

server — either the ID of a server or a Server instance.
network — the ID, or a Network instance, of the network from which a fixed IP address is about to be allocated.

Returns

None

`remove_fixed_ip_from_server(server, address)`

Removes a fixed IP address from a server instance. Bye girl 👋

Parameters

server — either the ID of a server or a Server instance.
address — the fixed IP address to be disassociated from the server.

Returns

None

`add_floating_ip_to_server(server, address, fixed_address=None)`

Adds a floating IP address to a server instance. Floating! Very main character energy 🌈

Parameters

server — either the ID of a server or a Server instance.
address — the floating IP address to be added to the server.
fixed_address — the fixed IP address to be associated with the floating IP address. Used when the server is connected to multiple networks. Like, specify which one, bestie.

Returns

None

`remove_floating_ip_from_server(server, address)`

Removes a floating IP address from a server instance. Floating no more 🦋

Parameters

server — either the ID of a server or a Server instance.
address — the floating IP address to be disassociated from the server.

Returns

None

🔥 Starting, Stopping, etc. 🔥

class openstack.compute.v2._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

`reboot_server(server, reboot_type)`

Reboots a server. The classic turn-it-off-and-on-again, but make it cloud ☁️

Parameters

server — either the ID of a server or a Server instance.
reboot_type — the type of reboot to perform. "HARD" and "SOFT" are the current options. That's it, those are the two.

Returns

None

`pause_server(server)`

Pauses a server and changes its status to PAUSED. Time out, bestie, take a breather 🧚

Parameters

server — either the ID of a server or a Server instance.

Returns

None

`unpause_server(server)`

Unpauses a paused server and changes its status to ACTIVE. Welcome back, we missed you 💖

Parameters

server — either the ID of a server or a Server instance.

Returns

None

`suspend_server(server)`

Suspends a server and changes its status to SUSPENDED. Not a pause — an actual suspend, okay, they're different 😭

Parameters

server — either the ID of a server or a Server instance.

Returns

None

`resume_server(server)`

Resumes a suspended server and changes its status to ACTIVE. And we're back, periodt 🔥

Parameters

server — either the ID of a server or a Server instance.

Returns

None

`lock_server(server, locked_reason=None)`

Locks a server. Nobody touches her, she's booked and busy 🔒

Parameters

server — either the ID of a server or a Server instance.
locked_reason — the reason behind locking the server. Limited to 255 characters in length. Keep it short, it's not a notes app.

Returns

None

`unlock_server(server)`

Unlocks a locked server. Free her 💅

Parameters

server — either the ID of a server or a Server instance.

Returns

None

`rescue_server(server, admin_pass=None, image=None)`

Puts a server in rescue mode and changes its status to RESCUE. Not a glow-up — a rescue 🚑

Parameters

server — either the ID of a server or a Server instance.
admin_pass — the password for the rescued server. If you omit this parameter, the operation generates a new password. So like, don't panic if you skip it.
image — the image reference to use to rescue your server. This can be the image ID or its full URL. If you omit this parameter, the base image reference will be used.

Returns

None

`unrescue_server(server)`

Unrescues a server and changes its status to ACTIVE. She's healed 💖

Parameters

server — either the ID of a server or a Server instance.

Returns

None

`evacuate_server(server, host=None, admin_pass=None, force=None, *, on_shared_storage=None)`

Evacuates a server from a failed host to a new host. Moving day, but make it emergency 🏃‍♀️

Lowkey dramatic: this one is for when a host has failed.

Parameters

server — either the ID of a server or a Server instance.

Still in the same server-move moment — here’s the rest of the param tea:

host — An optional parameter specifying the name or ID of the host to which the server is evacuated.
admin_pass — An optional parameter specifying the administrative password to access the evacuated or rebuilt server.
force — Force an evacuation by not verifying the provided destination host by the scheduler. (New in API version 2.29).
on_shared_storage — Whether the host is using shared storage. (Optional) (Only supported before API version 2.14)

Returns: None

🦋 `start_server(server)`

Starts a stopped server and changes its state to ACTIVE. Literally waking the poor thing up.

Parameters:

server — Either the ID of a server or a Server <#openstack.compute.v2.server.Server> instance.

Returns: None

🌸 `stop_server(server)`

Stops a running server and changes its state to SHUTOFF. Nap time, served.

Parameters:

server — Either the ID of a server or a Server <#openstack.compute.v2.server.Server> instance.

Returns: None

🎀 `restore_server(server)`

Restore a soft-deleted server. Bringing it back from the soft-delete void, no cap.

Parameters:

server — Either the ID of a server or a Server <#openstack.compute.v2.server.Server> instance.

Returns: None

💜 `shelve_server(server)`

Shelves a server.

All associated data and resources are kept but anything still in memory is not retained. Policy defaults enable only users with administrative role or the owner of the server to perform this operation. Cloud provides could change this permission though.

Parameters:

server — Either the ID of a server or a Server <#openstack.compute.v2.server.Server> instance.

Returns: None

✨ `unshelve_server(server, *, host=None, availability_zone=Unset.UNSET)`

Unshelves or restores a shelved server.

Policy defaults enable only users with administrative role or the owner of the server to perform this operation. Cloud provides could change this permission though.

Parameters:

server — Either the ID of a server or a Server <#openstack.compute.v2.server.Server> instance.
host — An optional parameter specifying the name the compute host to unshelve to. (New in API version 2.91).

Returns: None

🌈 `migrate_server(server, *, host=None)`

Migrate a server from one host to another. Moving day, but make it cloud.

Parameters:

server — Either the ID of a server or a Server <#openstack.compute.v2.server.Server> instance.
host — The host to which to migrate the server.

Returns: None

🔥 `live_migrate_server(server, host=None, force=False, block_migration=None, disk_over_commit=None)`

Live migrate a server from one host to target host. Yes, live — the server stays up while it moves, iconic behavior.

Parameters:

server — Either the ID of a server or a Server <#openstack.compute.v2.server.Server> instance.
host — The host to which to migrate the server. If the Nova service is too old, the host parameter implies force=True which causes the Nova scheduler to be bypassed. On such clouds, a ValueError will be thrown if host is given without force.
force — Force a live-migration by not verifying the provided destination host by the scheduler. This is unsafe and not recommended.
block_migration — Perform a block live migration to the destination host by the scheduler. Can be 'auto', True or False. Some clouds are too old to support 'auto', in which case a ValueError will be thrown. If omitted, the value will be 'auto' on clouds that support it, and False on clouds that do not.
disk_over_commit — Whether to allow disk over-commit on the destination host. (Optional)

Returns: None

💅 Modifying a Server 💅

class openstack.compute.v2._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

🧚 `change_server_password(server, new_password)`

Change the administrator password. New password, who dis?

Parameters:

server — Either the ID of a server or a Server <#openstack.compute.v2.server.Server> instance.
new_password — The new password to be set.

Returns: None

🍓 `get_server_password(server)`

Get the administrator password. No, I’m not telling you what it is — the API will.

Parameters:

server — Either the ID of a server or a Server <#openstack.compute.v2.server.Server> instance.

Returns: encrypted password.

🫶 `reset_server_state(server, state)`

Reset the state of server. State machine? More like state situation.

Parameters:

server — The server can be either the ID of a server or a Server <#openstack.compute.v2.server.Server>.
state — The state of the server to be set, active or error are valid.

Returns: None

👑 `rebuild_server(server, image, **attrs)`

Rebuild a server. Fresh start energy, but for compute.

Parameters:

server — Either the ID of a server or a Server <#openstack.compute.v2.server.Server> instance.
name — The name of the server
admin_password — The administrator password
preserve_ephemeral — Indicates whether the server is rebuilt with the preservation of the ephemeral partition. Default: False
image — The id of an image to rebuild with. Default: None
access_ipv4 — The IPv4 address to rebuild with. Default: None
access_ipv6 — The IPv6 address to rebuild with. Default: None
metadata — A dictionary of metadata to rebuild with. Default: None
personality — A list of dictionaries, each including a path and contents key, to be injected into the rebuilt server at launch. Default: None

Returns: The rebuilt Server <#openstack.compute.v2.server.Server> instance.

💖 `resize_server(server, flavor)`

Resize a server. Glow-up, but make it flavor-based.

Parameters:

server — Either the ID of a server or a Server <#openstack.compute.v2.server.Server> instance.
flavor — Either the ID of a flavor or a Flavor <#openstack.compute.v2.flavor.Flavor> instance.

Returns: None

⭐ `confirm_server_resize(server)`

Confirm a server resize. Lock it in, bestie.

Parameters:

server — Either the ID of a server or a Server <#openstack.compute.v2.server.Server> instance.

Returns: None

💀 `revert_server_resize(server)`

Revert a server resize. Actually, never mind — take it back.

Parameters:

server — Either the ID of a server or a Server <#openstack.compute.v2.server.Server> instance.

Returns: None

🎀 Image Operations 🎀

class openstack.compute.v2._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

🌸 `delete_image(image, ignore_missing=True)`

Delete an image. Bye-bye, snapshot queen.

Parameters:

image — The value can be either the ID of an image or a Image <#openstack.compute.v2.image.Image> instance.
ignore_missing — okay so when this is False, a NotFoundException gets raised if the image literally doesn't exist. Set it to True and no exception at all when you try to delete a nonexistent image — it just vibes. 💅

Returns Nothing, bestie. None. 🫶

find_image(name_or_id, ignore_missing=True) Find a single image 🎯

Parameters

name_or_id — the name or ID of a image.
ignore_missing — when set to False, a NotFoundException gets raised when the resource doesn't exist. When set to True, None is returned when you go looking for a nonexistent resource instead of the whole thing blowing up.

Returns One Image or None.

Raises NotFoundException when no resource can be found.

Raises DuplicateResource when multiple resources are found. 😭 (yes, that's a whole situation)

get_image(image) Get a single image ✨

Parameters

image — the value can be the ID of an image or an Image instance.

Returns One Image.

Raises NotFoundException when no resource can be found.

images(details=True, **query) Return a generator of images 🌈

Parameters

details — when True, returns Image objects with all available properties, otherwise only basic properties come back. Default: True.
query — optional query parameters, sent along to limit the resources being returned.

Returns A generator of image objects.

get_image_metadata(image) Return a dictionary of metadata for an image 🎀

Deprecated since version 4.14.0: use fetch_image_metadata() instead. Like, she's still here but she's not the moment anymore.

set_image_metadata(image, **metadata) Update metadata for an image 🌸

Parameters

image — either the ID of an image or an Image instance.
metadata — key/value pairs to be updated in the image's metadata. No other metadata is modified by this call. Periodt.

Returns An Image with only the image's metadata.

delete_image_metadata(image, keys=None) Delete metadata for an image 🦋

Note: this method will do a HTTP DELETE request for every key in keys. Not me making one request per key… but that's literally what it does, iykyk.

Parameters

image — either the ID of an image or an Image instance.
keys — the keys to delete. If omitted, all metadata is removed. Gone. ✨

Returns None.

👑 Flavor Operations 👑

class openstack.compute.v2._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

find_flavor(name_or_id, ignore_missing=True, *, get_extra_specs=False, **query) Find a single flavor 🍓

Parameters

name_or_id — the name or ID of a flavor.
ignore_missing — when set to False, a NotFoundException gets raised when the resource doesn't exist. When set to True, None is returned when attempting to find a nonexistent resource.
get_extra_specs — when set to True and extra_specs isn't present in the response, it'll invoke an additional API call to fetch extra_specs.
query — optional query parameters sent along to limit the flavors being returned.

Returns One Flavor or None.

Raises NotFoundException when no resource can be found.

Raises DuplicateResource when multiple resources are found. 💀

create_flavor(**attrs) Create a new flavor from attributes 🧚

Parameters

attrs — keyword arguments which will be used to create a Flavor, comprised of the properties on the Flavor class.

Returns The results of flavor creation.

delete_flavor(flavor, ignore_missing=True) Delete a flavor 💅

Parameters

flavor — the value can be either the ID of a flavor or a Flavor instance.
ignore_missing — when set to False, a NotFoundException gets raised when the flavor doesn't exist. When set to True, no exception will be set when attempting to delete a nonexistent flavor.

Returns None.

get_flavor(flavor, get_extra_specs=False) Get a single flavor ⭐

Parameters

flavor — the value can be the ID of a flavor or a Flavor instance.
get_extra_specs — when set to True and extra_specs isn't present in the response, it'll invoke an additional API call to fetch extra_specs.

Returns One Flavor.

Raises NotFoundException when no resource can be found.

flavors(details=True, get_extra_specs=False, **query) Return a generator of flavors 🌈

Parameters

details — when True, returns Flavor objects, with additional attributes filled.
get_extra_specs — when set to True and extra_specs isn't present in the response, it'll invoke an additional API call to fetch extra_specs.
query — optional query parameters sent along to limit the flavors being returned.

Returns A generator of flavor objects.

flavor_add_tenant_access(flavor, tenant) Adds tenant/project access to flavor. 🔥

Parameters

flavor — either the ID of a flavor or a Flavor instance.
tenant — the UUID of the tenant.

Returns None.

flavor_remove_tenant_access(flavor, tenant) Removes tenant/project access to flavor. 🙈

Parameters

flavor — either the ID of a flavor or a Flavor instance.
tenant — the UUID of the tenant.

Returns None.

get_flavor_access(flavor) Lists tenants who have access to private flavor 🎀

Parameters

flavor — either the ID of a flavor or a Flavor instance.

Returns List of dicts with flavor_id and tenant_id attributes.

fetch_flavor_extra_specs(flavor) Lists Extra Specs of a flavor ✨

Parameters

flavor — either the ID of a flavor or a Flavor instance.

Returns One Flavor.

create_flavor_extra_specs(flavor, extra_specs) Lists Extra Specs of a flavor 💜

Parameters

flavor — either the ID of a flavor or a Flavor instance.
extra_specs — dict of extra specs.

Returns One Flavor.

get_flavor_extra_specs_property(flavor, prop) Get specific Extra Spec property of a flavor 🔍

Parameters

flavor — either the ID of a flavor or a Flavor <#openstack.compute.v2.flavor.Flavor> instance, bestie. Both work, no cap.
prop — the property name. Just the name, okay? 💅

Returns

The string value of the property you asked for. That's it, that's the whole vibe. ✨

update_flavor_extra_specs_property(flavor, prop, val) — Update a specific Extra Spec property of a flavor. Target acquired, glow-up applied. 🎀

flavor — either the ID of a flavor or a Flavor <#openstack.compute.v2.flavor.Flavor> instance.
prop — the property name.
val — the property value. The new fit. 💖

Returns

String value of the requested property.

delete_flavor_extra_specs_property(flavor, prop, ignore_missing=True) — Delete a specific Extra Spec property of a flavor. It's giving "blocked, unfollowed, deleted." 💀

flavor — either the ID of a flavor or a Flavor <#openstack.compute.v2.flavor.Flavor> instance.
prop — the property name.
ignore_missing — okay so listen 🫶: when this is set to False, a NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the flavor or the extra spec doesn't exist. When it's set to True, no exception will be set when attempting to delete a nonexistent flavor extra spec. So True = unbothered, moisturized, in her lane. 💅

Returns

None. Nothing. Empty. Iconic minimalism. 🦋

🛠️ Service Operations 🛠️

Look at this constructor, she's long, she's detailed, she ate and left no crumbs 👑:

class openstack.compute.v2._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None, endpoint_override=None,
version=None, auth=None, user_agent=None, connect_retries=None, logger=None,
allow=None, additional_headers=None, client_name=None, client_version=None,
allow_version_hack=None, global_request_id=None, min_version=None,
max_version=None, default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None, status_code_retry_delay=None,
statsd_client=None, statsd_prefix=None, prometheus_counter=None,
prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

update_service_forced_down(service, host=None, binary=None, forced=True) — Update a service's forced_down info. Sometimes you just gotta manually declare a service down, iykyk. 🔥

service — either the ID of a service or a Service <#openstack.compute.v2.service.Service> instance.
host — the host where the service runs.
binary — the name of the service.
forced — whether or not this service was forced down manually by an administrator after the service was fenced. Yes, that's the literal meaning, don't come for me. 🙈

Returns

The updated service instance.

disable_service(service, host=None, binary=None, disabled_reason=None) — Disable a service. Sorry bestie, you're on timeout. 😭

service — either the ID of a service or a Service <#openstack.compute.v2.service.Service> instance.
host — the host where the service runs.
binary — the name of the service.
disabled_reason — the reason of force down a service. Spill the tea, write it down. 🍓

Returns

The updated service instance.

enable_service(service, host=None, binary=None) — Enable a service. Timeout's over, welcome back queen 👑✨

service — either the ID of a service, a Service <#openstack.compute.v2.service.Service> instance, or None.
host — the host where the service runs.
binary — the name of the service.

Returns

The updated service instance.

services(**query) — Return a generator of service. Generators are lowkey the moment, they don't dump everything at once. 🌸

query — query parameters.

Returns

A generator of service.

find_service(name_or_id, ignore_missing=True, **query) — Find a service from a name or an id so you can get the corresponding info. Detective mode: activated 🕵️‍♀️

name_or_id — the name or id of a service.
ignore_missing — when set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the resource does not exist. When set to True, None will be returned when attempting to find a nonexistent resource. No drama, just None. 🦋
query — additional attributes like 'host'.

Returns

One: class:~openstack.compute.v2.service.Service or None.

Raises

NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found.

DuplicateResource <#openstack.exceptions.DuplicateResource> when multiple resources are found. Two answers?? Not the plot twist 💀

delete_service(service, ignore_missing=True) — Delete a service.

service — the value can be either the ID of a service or a Service <#openstack.compute.v2.service.Service> instance.
ignore_missing — when set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the service does not exist. When set to True, no exception will be set when attempting to delete a nonexistent service.

Returns

None.

update_service(service, **attrs) — Update a service. Glow-up szn 💖

service — either the ID of a service or a Service <#openstack.compute.v2.service.Service> instance.
attrs — the attributes to update on the service represented by service.

Returns

The updated service.

And here's the constructor again, same energy, still long, still serving:

class openstack.compute.v2._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None, endpoint_override=None,
version=None, auth=None, user_agent=None, connect_retries=None, logger=None,
allow=None, additional_headers=None, client_name=None, client_version=None,
allow_version_hack=None, global_request_id=None, min_version=None,
max_version=None, default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None, status_code_retry_delay=None,
statsd_client=None, statsd_prefix=None, prometheus_counter=None,
prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

create_share_attachment(server, share, **attrs) — Create a new share attachment from attributes. Matchmaker, matchmaker, attach that share 💅

server — the value can be either the ID of a server or a Server <#openstack.compute.v2.server.Server> instance that the share is attached to.
share — the value can be the ID of a share or a Share instance.
attrs — keyword arguments which will be used to create a ShareMapping, comprised of the properties on the ShareMapping class. Yes, comprised of, we're fancy now. 🎀

Returns

The results of create share.

delete_share_attachment(server, share, ignore_missing=True) — Delete a share attachment. Unattach. Detach. Release the bond 😭

server — the value can be either the ID of a server or a Server <#openstack.compute.v2.server.Server> instance that the share is attached to.
share — the value can be the ID of a share or a Share instance.
ignore_missing — when set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the resource does not exist. When set to True, no exception will be set when attempting to delete a nonexistent resource.

Returns

None.

get_share_attachment(server, share) — Get a single share attachment. Just one. Quality over quantity, bestie ✨

server — the value can be either the ID of a server or a Server <#openstack.compute.v2.server.Server> instance that the share is attached to.
share — the value can be the ID of a share or a Share instance.

Returns

One ShareMapping.

Raises

NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found.

share_attachments(server, **query) — Return a generator of share attachments. All of them, streaming in, one by one 🌊

server — the server can be either the ID of a server or a Server <#openstack.compute.v2.server.Server>.
query — query parameters.

Returns

A generator of ShareMapping objects ShareMapping.

📎 Volume Attachment Operations 💅

Okay so this is the volume-attachment zone, and yes — it's the same big proxy class as before, with the same thirty-something kwargs. I'm putting the full signature again because the manual does, and because bestie we do not skip things in this house 🫶

class openstack.compute.v2._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

create_volume_attachment(server, volume=None, **attrs) — makes a shiny new volume attachment out of the attributes you pass in ✨

server — the value can be either the ID of a server, or a Server <#openstack.compute.v2.server.Server> instance that the volume is attached to.
volume — the value can be either the ID of a volume, or a Volume <#openstack.block_storage.v3.volume.Volume> instance.
attrs — keyword arguments which will be used to create a VolumeAttachment <#openstack.compute.v2.volume_attachment.VolumeAttachment>, comprised of the properties on the VolumeAttachment class.

Returns: the results of volume attachment creation 🎀

update_volume_attachment(server, volume, volume_id=None, **attrs) — updates a volume attachment

Heads up bestie, this one's important 👀 the underlying API expects a volume ID, not a volume attachment ID. There is currently no way to update volume attachments by their own ID. So don't come for it, that's just how it is 😭

server — the value can be either the ID of a server, or a Server <#openstack.compute.v2.server.Server> instance that the volume is attached to.
volume — the value can be either the ID of a volume, or a Volume <#openstack.block_storage.v3.volume.Volume> instance.
volume_id — the ID of a volume to swap to. If this is not specified, we will default to not swapping the volume.
attrs — the attributes to update on the volume attachment represented by volume_attachment.

Returns: None

delete_volume_attachment(server, volume, ignore_missing=True) — yeets a volume attachment into the void 💀

Same vibe check as above: the underlying API expects a volume ID, not a volume attachment ID. There is currently no way to delete volume attachments by their own ID.

server — the value can be either the ID of a server, or a Server <#openstack.compute.v2.server.Server> instance that the volume is attached to.
volume — the value can be the ID of a volume, or a Volume <#openstack.block_storage.v3.volume.Volume> instance.
ignore_missing — when set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the volume attachment does not exist. When set to True, no exception will be set when attempting to delete a nonexistent volume attachment.

Returns: None

get_volume_attachment(server, volume) — gets you one single volume attachment 🔍

And again, because the universe is testing us: the underlying API expects a volume ID, not a volume attachment ID. There is currently no way to retrieve volume attachments by their own ID.

server — the value can be either the ID of a server, or a Server <#openstack.compute.v2.server.Server> instance that the volume is attached to.
volume — the value can be the ID of a volume, or a Volume <#openstack.block_storage.v3.volume.Volume> instance.

Returns: one VolumeAttachment <#openstack.compute.v2.volume_attachment.VolumeAttachment>

Raises: NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found. 😬

volume_attachments(server, **query) — returns a generator of volume attachments, lowkey the comfy way to iterate 🌸

server — the server can be either the ID of a server, or a Server <#openstack.compute.v2.server.Server>.
query — query parameters.

Returns: a generator of VolumeAttachment objects — VolumeAttachment <#openstack.compute.v2.volume_attachment.VolumeAttachment>

🔑 Keypair Operations 🔑

Back at it with the exact same proxy class, because consistency is iconic 👑

class openstack.compute.v2._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

create_keypair(**attrs) — creates a fresh new keypair from attributes 🔐

attrs — keyword arguments which will be used to create a Keypair <#openstack.compute.v2.keypair.Keypair>, comprised of the properties on the Keypair class.

Returns: the results of keypair creation ✨

delete_keypair(keypair, ignore_missing=True, user_id=None) — deletes a keypair, no cap 🗑️

keypair — the value can be either the ID of a keypair, or a Keypair <#openstack.compute.v2.keypair.Keypair> instance.
ignore_missing — when set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the keypair does not exist. When set to True, no exception will be set when attempting to delete a nonexistent keypair.
user_id — optional user_id owning the keypair.

Returns: None

get_keypair(keypair, user_id=None) — gets you a single keypair 💖

keypair — the value can be either the ID of a keypair, or a Keypair <#openstack.compute.v2.keypair.Keypair> instance.
user_id — optional user_id owning the keypair.

Returns: one Keypair <#openstack.compute.v2.keypair.Keypair>

Raises: NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found. 😭

find_keypair(name_or_id, ignore_missing=True, *, user_id=None) — hunts down a single keypair for you, main character energy 🕵️‍♀️

name_or_id — the name or ID of a keypair.
ignore_missing — when set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the resource does not exist. When set to True, None will be returned when attempting to find a nonexistent resource.
user_id — optional user_id owning the keypair.

Returns: one Keypair <#openstack.compute.v2.keypair.Keypair> or None

Raises: NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found.

Raises: DuplicateResource <#openstack.exceptions.DuplicateResource> when multiple resources are found. Yeah, if there's more than one match it's gonna be messy 🙈

keypairs(**query) — returns a generator of keypairs, go off 🔥

query — optional query parameters to be sent to limit the resources being returned.

Returns: a generator of keypair objects

🌐 Server IPs 🌐

One more time, the exact same proxy class — yes the whole kwargs list, here it is, character for character 🎀

class openstack.compute.v2._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

server_ips(server, network_label=None) — returns a generator of server IPs, iykyk 🌈

server — the server can be either the ID of a server, or a Server <#openstack.compute.v2.server.Server>.
network_label — the name of a particular network to list IP addresses from.

That's the IPs handled — keep scrolling bestie, the next chunk is literally right below 💖

Returns — a generator of ServerIP objects ✨ that's the last little return from the Server IP zone, bestie.

🌸 Server Group Operations 🌸

okay so these methods hang off the Proxy class, and the full signature is a whole mood — copy it exactly, no cap:

class openstack.compute.v2._proxy.Proxy(session, *, service_type=None,
       service_name=None, interface=None, region_name=None,
       endpoint_override=None, version=None, auth=None, user_agent=None,
       connect_retries=None, logger=None, allow=None, additional_headers=None,
       client_name=None, client_version=None, allow_version_hack=None,
       global_request_id=None, min_version=None, max_version=None,
       default_microversion=None, status_code_retries=None,
       retriable_status_codes=None, raise_exc=None, rate_limit=None,
       concurrency=None, connect_retry_delay=None,
       status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
       prometheus_counter=None, prometheus_histogram=None,
       influxdb_config=None, influxdb_client=None)

`create_server_group(**attrs)` — create a new server group from attributes

Parameters:

attrs — keyword arguments that get used to create a ServerGroup (openstack.compute.v2.server_group.ServerGroup), made up of the properties on the ServerGroup class. literally building the vibe from the class props 💅

Returns — the results of server group creation ✨

`delete_server_group(server_group, ignore_missing=True)` — delete a server group

Parameters:

server_group — the value can be either the ID of a server group or a ServerGroup (openstack.compute.v2.server_group.ServerGroup) instance.
ignore_missing — when set to False, NotFoundException (openstack.exceptions.NotFoundException) will be raised when the server group does not exist. When set to True, no exception will be set when attempting to delete a nonexistent server group. bestie said “if it’s not there, we move on” 🫶

Returns — None

`find_server_group(name_or_id, ignore_missing=True, *, all_projects=False)` — find a single server group

Parameters:

name_or_id — the name or ID of a server group.
ignore_missing — when set to False, NotFoundException (openstack.exceptions.NotFoundException) will be raised when the resource does not exist. When set to True, None will be returned when attempting to find a nonexistent resource.
all_projects — when set to True, search for server groups by name across all projects. Note that this will likely result in a higher chance of duplicates. Admin-only by default. so true, it’s giving “look everywhere” energy 👀

Returns — one ServerGroup (openstack.compute.v2.server_group.ServerGroup) or None

Raises NotFoundException (openstack.exceptions.NotFoundException) when no resource can be found.

Raises DuplicateResource (openstack.exceptions.DuplicateResource) when multiple resources are found. not two of them, bestie 😭

`get_server_group(server_group)` — get a single server group

Parameters:

server_group — the value can be the ID of a server group or a ServerGroup (openstack.compute.v2.server_group.ServerGroup) instance.

Returns — a ServerGroup (openstack.compute.v2.server_group.ServerGroup) object.

Raises NotFoundException (openstack.exceptions.NotFoundException) when no resource can be found.

`server_groups(*, all_projects=False, **query)` — return a generator of server groups

Parameters:

all_projects — when set to True, lists servers groups (yes, that's what the page says 👀) from all projects. Admin-only by default.
query — optional query parameters to be sent to limit the resources being returned.

Returns — a generator of ServerGroup objects 🌈

🦋 Server Interface Operations 🦋

same Proxy energy, same full signature — here it is again, exactly:

class openstack.compute.v2._proxy.Proxy(session, *, service_type=None,
       service_name=None, interface=None, region_name=None,
       endpoint_override=None, version=None, auth=None, user_agent=None,
       connect_retries=None, logger=None, allow=None, additional_headers=None,
       client_name=None, client_version=None, allow_version_hack=None,
       global_request_id=None, min_version=None, max_version=None,
       default_microversion=None, status_code_retries=None,
       retriable_status_codes=None, raise_exc=None, rate_limit=None,
       concurrency=None, connect_retry_delay=None,
       status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
       prometheus_counter=None, prometheus_histogram=None,
       influxdb_config=None, influxdb_client=None)

`create_server_interface(server, **attrs)` — create a new server interface from attributes

Parameters:

server — the server can be either the ID of a server or a Server (openstack.compute.v2.server.Server) instance that the interface belongs to.
attrs — keyword arguments which will be used to create a ServerInterface (openstack.compute.v2.server_interface.ServerInterface), comprised of the properties on the ServerInterface class.

Returns — the results of server interface creation ✨

`delete_server_interface(server_interface, server=None, ignore_missing=True)` — delete a server interface

Parameters:

server_interface — the value can be either the ID of a server interface or a ServerInterface (openstack.compute.v2.server_interface.ServerInterface) instance.
server — this parameter need to be specified when ServerInterface ID is given as value. It can be either the ID of a server or a Server (openstack.compute.v2.server.Server) instance that the interface belongs to.
ignore_missing — when set to False, NotFoundException (openstack.exceptions.NotFoundException) will be raised when the server interface does not exist. When set to True, no exception will be set when attempting to delete a nonexistent server interface.

Returns — None

`get_server_interface(server_interface, server=None)` — get a single server interface

Parameters:

server_interface — the value can be the ID of a server interface or a ServerInterface (openstack.compute.v2.server_interface.ServerInterface) instance.
server — this parameter need to be specified when ServerInterface ID is given as value. It can be either the ID of a server or a Server (openstack.compute.v2.server.Server) instance that the interface belongs to.

Returns — one ServerInterface (openstack.compute.v2.server_interface.ServerInterface)

Raises NotFoundException (openstack.exceptions.NotFoundException) when no resource can be found.

`server_interfaces(server, **query)` — return a generator of server interfaces

Parameters:

server — the server can be either the ID of a server or a Server (openstack.compute.v2.server.Server).
query — optional query parameters to be sent to limit the resources being returned.

Returns — a generator of ServerInterface objects 🎀

💜 Server Tag Operations 💜

one more Proxy signature moment, because the manual page said so and we respect the manual page:

class openstack.compute.v2._proxy.Proxy(session, *, service_type=None,
       service_name=None, interface=None, region_name=None,
       endpoint_override=None, version=None, auth=None, user_agent=None,
       connect_retries=None, logger=None, allow=None, additional_headers=None,
       client_name=None, client_version=None, allow_version_hack=None,
       global_request_id=None, min_version=None, max_version=None,
       default_microversion=None, status_code_retries=None,
       retriable_status_codes=None, raise_exc=None, rate_limit=None,
       concurrency=None, connect_retry_delay=None,
       status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
       prometheus_counter=None, prometheus_histogram=None,
       influxdb_config=None, influxdb_client=None)

`add_tag_to_server(server, tag)` — add a tag to a server.

Parameters:

server — either the ID of a server or a Server (openstack.compute.v2.server.Server) instance.
tag — the tag to add.

Returns — None

`remove_tag_from_server(server, tag)` — remove a tag from a server.

Parameters:

server — either the ID of a server or a Server (openstack.compute.v2.server.Server) instance.
tag — the tag to remove.

Returns — None

`remove_tags_from_server(server)` — remove all tags from a server.

Parameters:

server — either the ID of a server or a Server (openstack.compute.v2.server.Server) instance.
tag — the tag to remove. (the page lists tag here even though the signature is just server — iconic documentation behavior 💀)

Returns — None 💅

🌸 Server External Event Operations 🌸

class openstack.compute.v2._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

Ok so the methods on this one, bestie 👇

create_server_external_events(events) — makes one or more server external events. Plural. A whole lil batch. 💅

⚠️ Warning: this API is intended for inter-service communication only (e.g. Neutron, Cyborg notifying Nova about events). So like... it's for the services talking to each other, not for you to be messy with. Respect the group chat boundaries fr fr 🙈

Parameters

events — List of dicts, each containing event attributes (name, server_uuid, status, tag).

Returns

A generator of ServerExternalEvent — a generator, so it's giving "I'll give you the events one at a time, be patient" energy ✨

🦋 Availability Zone Operations 🦋

class openstack.compute.v2._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

availability_zones(details=False) — returns a generator of availability zones. The zones!! The places your stuff lives!! 🌈

Parameters

details — Return extra details about the availability zones. This defaults to False as it generally requires extra permission. So like, lowkey the extra tea is behind a permission wall 🔒 — that's why False is the default, it's not being shady, it's being polite.

Returns

A generator of availability zone AvailabilityZone <#openstack.compute.v2.availability_zone.AvailabilityZone> 🎀

💜 Limits Operations 💜

class openstack.compute.v2._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

get_limits(**query) — retrieves the limits that are applied to the project's account. Your ceilings, your caps, the "no you can't have infinite of that" receipts 📋✨

Returns

A Limits object, including both AbsoluteLimits <#openstack.compute.v2.limits.AbsoluteLimits> and RateLimits. Two for one, we love a combo 💅

⭐ Hypervisor Operations ⭐

class openstack.compute.v2._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

hypervisors(details=False, **query) — returns a generator of hypervisors. The actual physical(ish) machines hosting your vibes 🖥️💖

Parameters

details — When set to the default, False, Hypervisor <#openstack.compute.v2.hypervisor.Hypervisor> instances will be returned with only basic information populated. Just the headline, not the whole story.
query — Optional query parameters to be sent to limit the resources being returned. Filter away, bestie 🔍

Returns

A generator of hypervisor.

find_hypervisor(name_or_id, ignore_missing=True, *, details=True) — finds a single hypervisor. One (1) hypervisor, specifically, no extras 👑

Parameters

name_or_id — The name or ID of a hypervisor.
ignore_missing — When set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the resource does not exist. When set to True, None will be returned when attempting to find a nonexistent resource. So True = "it's fine, no drama", False = "I want the error, I want the truth" 😭
details — When set to False, instances with only basic data will be returned. The default, True, will cause instances with full data to be returned. Note the flip from hypervisors() above — here it defaults to True, ok? Don't mix them up 💀

Returns

One: class:~openstack.compute.v2.hypervisor.Hypervisor or None.

Raises NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found.

Raises DuplicateResource <#openstack.exceptions.DuplicateResource> when multiple resources are found. Yes, multiple. Chaos. Not the vibe 🙈

get_hypervisor(hypervisor) — gets a single hypervisor.

Parameters

hypervisor — The value can be the ID of a hypervisor or a Hypervisor <#openstack.compute.v2.hypervisor.Hypervisor> instance. ID or the whole object, dealer's choice 🎲

Returns

A Hypervisor <#openstack.compute.v2.hypervisor.Hypervisor> object.

Raises NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found.

get_hypervisor_uptime(hypervisor) — gets uptime information for a hypervisor. How long has it been awake, bestie, when did it last sleep 😴⏱️

Parameters

hypervisor — The value can be the ID of a hypervisor or a Hypervisor <#openstack.compute.v2.hypervisor.Hypervisor> instance.

Returns

A Hypervisor <#openstack.compute.v2.hypervisor.Hypervisor> object.

Raises NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found.

🧚 Extension Operations 🧚

class openstack.compute.v2._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

find_extension(name_or_id, ignore_missing=True) — finds a single extension. Extensions are the little bonus features, the add-ons, the accessories of the compute world 🎀

Parameters

name_or_id — The name or ID of an extension.
ignore_missing — When set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the resource does not exist. When set to True, None will be returned when attempting to find a nonexistent resource.

Returns

One Extension <#openstack.compute.v2.extension.Extension> or None.

Raises NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found.

Raises DuplicateResource <#openstack.exceptions.DuplicateResource> when multiple resources are found.

extensions() — retrieves a generator of extensions. All of them. The whole collection. Slay ✨

Returns

A generator of extension instances.

🍓 QuotaClassSet Operations 🍓

class openstack.compute.v2._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

get_quota_class_set(quota_class_set='default') — gets a single quota class set.

Only one quota class is permitted, default. That's it. One class. There is no other class. Don't go looking 👀

Parameters

quota_class_set — The value can be the ID of a quota class set (only default is supported) or a QuotaClassSet instance.

Returns

One QuotaClassSet.

Raises NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found.

update_quota_class_set(quota_class_set, **attrs) — updates a QuotaClassSet.

Only one quota class is permitted, default. Same rule, still true, we're not being repetitive, the API is 💅

Parameters

quota_class_set — either the ID of a quota class set (and listen, only default is supported, so don't get creative 💅) or a QuotaClassSet instance.
attrs — the attributes you wanna update on the QuotaClassSet that quota_class_set is representing.

Returns

The updated QuotaSet ✨

🎀 QuotaSet Operations 🎀

class openstack.compute.v2._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

`get_quota_set(project, usage=False, **query)`

Show ya the QuotaSet info for the project 👑

Parameters

project — ID or instance of Project <#openstack.identity.v3.project.Project> for the project you want the quota for.
usage — when you set this to True, quota usage and reservations get filled in. Obsessed with the receipts 📊
query — extra query parameters to use, if you're feeling extra.

Returns

One QuotaSet <#openstack.compute.v2.quota_set.QuotaSet> 💖

Raises NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found. (Yeah. It's gone. 😭)

`get_quota_set_defaults(project)`

Show ya the QuotaSet defaults for the project — like, the factory settings era ✨

Parameters

project — ID or instance of Project <#openstack.identity.v3.project.Project> for the project you want the quota for.

Returns

One QuotaSet <#openstack.compute.v2.quota_set.QuotaSet>

Raises NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found.

`revert_quota_set(project, **query)`

Reset the quota for the project/user. Ctrl+Z but make it cloud 🫶

Parameters

project — ID or instance of Project <#openstack.identity.v3.project.Project> for the project you wanna reset the quota on.
query — additional parameters to be used.

Returns

None — yeah, nothing back, it just does the thing 💅

`update_quota_set(project, *, user=None, **attrs)`

Update a QuotaSet. Glow-up szn 🔥

Parameters

project — ID or instance of Project <#openstack.identity.v3.project.Project> for the project you wanna update the quota on.
user_id — optional ID of the user to set quotas as.
attrs — the attributes to update on the QuotaSet that quota_set is representing.

Returns

The updated QuotaSet

🦋 Server Migration Operations 🦋

class openstack.compute.v2._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

`abort_server_migration(server_migration, server, ignore_missing=True)`

Abort an in-progress server migration. Not me pulling the plug mid-move 💀

Parameters

server_migration — the value can be either the ID of a server migration or a ServerMigration <#openstack.compute.v2.server_migration.ServerMigration> instance.
server — you have to specify this when a ServerMigration ID is given as the value. It can be either the ID of a server or a Server <#openstack.compute.v2.server.Server> instance that the migration belongs to.
ignore_missing — when set to False, NotFoundException <#openstack.exceptions.NotFoundException> gets raised when the server migration doesn't exist. When set to True, no exception gets set when you attempt to delete a nonexistent server migration. (Yes, it says "delete" in a migration function. Iconic. 🙈)

Returns

None

`force_complete_server_migration(server_migration, server=None)`

Force complete an in-progress server migration. No cap, we finishing this ✨

Parameters

server_migration — the value can be either the ID of a server migration or a ServerMigration <#openstack.compute.v2.server_migration.ServerMigration> instance.
server — you have to specify this when a ServerMigration ID is given as the value. It can be either the ID of a server or a Server <#openstack.compute.v2.server.Server> instance that the migration belongs to.

Returns

None

`get_server_migration(server_migration, server, ignore_missing=True)`

Get a single server migration. Just the one. Main character energy 👑

Parameters

server_migration — the value can be the ID of a server migration or a ServerMigration <#openstack.compute.v2.server_migration.ServerMigration> instance.
server — this parameter needs to be specified when a ServerMigration ID is given as the value. It can be either the ID of a server or a Server <#openstack.compute.v2.server.Server> instance that the migration belongs to.
ignore_missing — when set to False, NotFoundException <#openstack.exceptions.NotFoundException> gets raised when the server migration doesn't exist. When set to True, no exception gets set when you attempt to delete a nonexistent server migration.

Returns

One ServerMigration <#openstack.compute.v2.server_migration.ServerMigration> 🌸

Create a remote console on the server. (Yeah, the description is literally the same as the one above it — nope, not me being lazy, that's genuinely what it says, iykyk 💀)

Parameters

server — either the ID of a server, or a Server <#openstack.compute.v2.server.Server> instance. either one works bestie 💫
console_type — the type of the console connection.

Returns — a dictionary with the console type and url 🎀

validate_console_auth_token(console_token) Look up console connection info for a console auth token. iykyk ✨

Parameters

console_token — the console auth token, exactly as it came back in the URL from get_server_console_url.

Returns — a dictionary with connection details, and ngl those details vary depending on the console type.

get_server_console_output(server, length=None) Grab the console output for a server. literally just the log 💅

Parameters

server — either the ID of a server, or a Server <#openstack.compute.v2.server.Server> instance.
length — optional, the number of lines to fetch from the end of the console log. leave it out and you get all the lines, no cap.

Returns — the console output as a dict. control characters get escaped so it's a valid JSON string 🫶

create_console(server, console_type, console_protocol=None) Create a remote console on the server. main character behaviour honestly 👑

when the microversion supported is higher than 2.6, a remote console gets created; otherwise it falls back to the deprecated call to get the server console. so yeah, older microversion = deprecated path, be aware 😭

Parameters

server — either the ID of a server, or a Server <#openstack.compute.v2.server.Server> instance.
console_type — the type of the remote console. supported values are: novnc, spice-html5, rdp-html5, serial, webmks (supported after 2.8), spice-direct (supported after 2.99).
console_protocol — optional console protocol. heads up: it's only respected after microversion 2.6.

Returns — a dictionary with the console type, the connection details (a url), and optionally the protocol ✨

✨ Helpers ✨

okay so this is the proxy class itself, and she has a LOT of keyword arguments. every single one, coming right up 💖

class openstack.compute.v2._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

wait_for_delete(res, interval=2, wait=120, callback=None) Wait for a resource to be deleted. she will sit there and watch it disappear, iconic patience 🧚

Parameters

res — the resource to wait on to be deleted.
interval — number of seconds to wait before two consecutive checks. default is 2.
wait — maximum number of seconds to wait before the change. default is 120.
callback — a callback function. it gets called with a single value, progress, which is a percentage value from 0-100.

Returns — the resource is returned on success 🎀

Raises ResourceTimeout <#openstack.exceptions.ResourceTimeout> if the transition to delete failed to occur in the specified seconds. so like, don't just wait forever, mmkay?

🌈 Container Infrastructure Management 🌈

🦋 Cluster Operations 🦋

class openstack.container_infrastructure_management.v1._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

create_cluster(**attrs) Create a new cluster from attributes. fresh cluster, fresh vibes ✨

Parameters

attrs — keyword arguments which will be used to create a Cluster <#openstack.container_infrastructure_management.v1.cluster.Cluster>, comprised of the properties on the Cluster class.

Returns — the results of cluster creation 💫

delete_cluster(cluster, ignore_missing=True) Delete a cluster. bye bestie 👋

Parameters

cluster — the value can be either the ID of a cluster or a Cluster <#openstack.container_infrastructure_management.v1.cluster.Cluster> instance.
ignore_missing — when set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the cluster does not exist. when set to True, no exception will be set when attempting to delete a nonexistent cluster. default is True, so she's chill about it 🙈

Returns — None

find_cluster(name_or_id, ignore_missing=True) Find a single cluster. the search is ON 🔍

Parameters

name_or_id — the name or ID of a cluster.
ignore_missing — when set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the resource does not exist. when set to True, None will be returned when attempting to find a nonexistent resource.

Returns — one Cluster <#openstack.container_infrastructure_management.v1.cluster.Cluster> or None 🫶

get_cluster(cluster) Get a single cluster. just the one, not a whole crowd 💅

Parameters

cluster — the value can be the ID of a cluster or a Cluster <#openstack.container_infrastructure_management.v1.cluster.Cluster> instance.

Returns — one Cluster <#openstack.container_infrastructure_management.v1.cluster.Cluster>

Raises NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found. 😭

clusters(**query) Return a generator of clusters. a whole lil generator of them, we love a lazy iterator 🌸

Parameters

query — optional query parameters to be sent to limit the resources being returned.

Returns — a generator of cluster objects Cluster <#openstack.container_infrastructure_management.v1.cluster.Cluster> 🔥

update_cluster(cluster, **attrs) Update a cluster. glow-up time 💖

Parameters

cluster — either the id of a cluster or a Cluster <#openstack.container_infrastructure_management.v1.cluster.Cluster> instance.
attrs — the attributes to update on the cluster represented by cluster.

Returns — the updated cluster ✨

🎀 Cluster Certificates Operations 🎀

class openstack.container_infrastructure_management.v1._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

create_cluster_certificate(**attrs) Create a new cluster_certificate from a CSR. certificates, but make it cute 🎀

Parameters

attrs — keyword arguments which will be used to create a ClusterCertificate <#openstack.container_infrastructure_management.v1.cluster_certificate.ClusterCertificate>, comprised of the properties on the ClusterCertificate class.

Returns — the results of cluster_certificate creation ⭐

get_cluster_certificate(cluster_certificate) Get a single cluster_certificate. one (1) certificate, coming right up 🦋

Parameters

cluster_certificate — the value can be the ID of a cluster_certificate or a ClusterCertificate <#openstack.container_infrastructure_management.v1.cluster_certificate.ClusterCertificate> instance.

Returns — one ClusterCertificate <#openstack.container_infrastructure_management.v1.cluster_certificate.ClusterCertificate>

Raises NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found. 💀

🎀 Cluster Templates Operations 🎀

First up: the class herself. Say hi to the proxy, she's got a lot of keyword args and honestly she's thriving:

class openstack.container_infrastructure_management.v1._proxy.Proxy(session,
*, service_type=None, service_name=None, interface=None,
region_name=None, endpoint_override=None, version=None, auth=None,
user_agent=None, connect_retries=None, logger=None, allow=None,
additional_headers=None, client_name=None, client_version=None,
allow_version_hack=None, global_request_id=None, min_version=None,
max_version=None, default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

create_cluster_template(**attrs) — makes a brand-new cluster template out of attributes, main character behavior only 💅

Parameters

attrs — keyword arguments that get used to create a ClusterTemplate <#openstack.container_infrastructure_management.v1.cluster_template.ClusterTemplate>, made up of the properties on the ClusterTemplate class.

Returns The results of cluster_template creation ✨

delete_cluster_template(cluster_template, ignore_missing=True) — bye bye cluster template, no notes 🫶

Parameters

cluster_template — the value can be either the ID of a cluster_template or a ClusterTemplate <#openstack.container_infrastructure_management.v1.cluster_template.ClusterTemplate> instance.
ignore_missing — when set to False, NotFoundException <#openstack.exceptions.NotFoundException> gets raised when the cluster_template doesn't exist. When set to True, no exception will be set when attempting to delete a nonexistent cluster_template.

Returns None

find_cluster_template(name_or_id, ignore_missing=True) — hunts down a single cluster_template, lowkey a detective 🔍

Parameters

name_or_id — the name or ID of a cluster_template.
ignore_missing — when set to False, NotFoundException <#openstack.exceptions.NotFoundException> gets raised when the resource doesn't exist. When set to True, None gets returned when attempting to find a nonexistent resource.

Returns One ClusterTemplate <#openstack.container_infrastructure_management.v1.cluster_template.ClusterTemplate> or None

get_cluster_template(cluster_template) — grabs a single cluster_template, no gatekeeping 🎀

Parameters

cluster_template — the value can be the ID of a cluster_template or a ClusterTemplate <#openstack.container_infrastructure_management.v1.cluster_template.ClusterTemplate> instance.

Returns One ClusterTemplate <#openstack.container_infrastructure_management.v1.cluster_template.ClusterTemplate>

Raises NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found 😭

cluster_templates(**query) — returns a generator of cluster_templates, she gives and she gives 🌸

Parameters

query — optional query parameters to be sent to limit the resources being returned.

Returns A generator of cluster_template objects ClusterTemplate <#openstack.container_infrastructure_management.v1.cluster_template.ClusterTemplate>

update_cluster_template(cluster_template, **attrs) — glow-up time for your cluster_template ✨

Parameters

cluster_template — either the id of a cluster_template or a ClusterTemplate <#openstack.container_infrastructure_management.v1.cluster_template.ClusterTemplate> instance.
attrs — the attributes to update on the cluster_template represented by cluster_template.

Returns The updated cluster_template 👑

🌈 Service Operations 🌈

Same class, same absolutely iconic wall of keyword args, so here she is again in full because we do not skip details in this house:

class openstack.container_infrastructure_management.v1._proxy.Proxy(session,
*, service_type=None, service_name=None, interface=None,
region_name=None, endpoint_override=None, version=None, auth=None,
user_agent=None, connect_retries=None, logger=None, allow=None,
additional_headers=None, client_name=None, client_version=None,
allow_version_hack=None, global_request_id=None, min_version=None,
max_version=None, default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

services() — returns a generator of services, she's a whole vibe check on what's running 🔥

Returns A generator of service objects Service <#openstack.container_infrastructure_management.v1.service.Service>

💜 Database API 💜

So for the full rundown on how to actually use database, go peep Using OpenStack Database <>. That's the homework bestie, iykyk 📚

🦋 The Database Class 🦋

The database high-level interface lives through the database member of a Connection <#openstack.connection.Connection> object. Important detail fr fr: that database member only gets added if the service is detected. No service, no member, that's just how it is 🫶

🍓 Database Operations 🍓

Once more with feeling — the proxy class, exact same signature, character for character:

class openstack.database.v1._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

create_database(instance, **attrs) — creates a new database from attributes, new database just dropped 💅

Parameters

instance — this can be either the ID of an instance or a Instance <#openstack.database.v1.instance.Instance>
attrs — keyword arguments which will be used to create a Database <#openstack.database.v1.database.Database>, comprised of the properties on the Database class.

Returns The results of server creation

delete_database(database, instance=None, ignore_missing=True) — deletes a database, gone girl energy 😭

Parameters

database — the value can be either the ID of a database or a Database <#openstack.database.v1.database.Database> instance.
instance — this parameter needs to be specified when an ID is given as database. It can be either the ID of an instance or a Instance <#openstack.database.v1.instance.Instance>
ignore_missing — when set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the database doesn't exist. When set to True, no exception will be set when attempting to delete a nonexistent database.

Returns None

find_database(name_or_id, instance, ignore_missing=True) — finds a single database, sleuth mode activated 🕵️‍♀️

Parameters

name_or_id — the name or ID of a database.
instance — this can be either the ID of an instance or a Instance <#openstack.database.v1.instance.Instance>
ignore_missing — when set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the resource doesn't exist. When set to True, None will be returned when attempting to find a nonexistent resource.

Returns One Database <#openstack.database.v1.database.Database> or None

databases(instance, **query) — returns a generator of databases, the whole collection, no crumbs 🌈

Parameters

instance — this can be either the ID of an instance or a Instance <#openstack.database.v1.instance.Instance> instance that the interface belongs to.
query — optional query parameters to be sent to limit the resources being returned.

Returns A generator of database objects

get_database(database, instance=None) — gets a single database, bestie delivers 📦

Parameters

instance — this parameter needs to be specified when an ID is given as database. It can be either the ID of an instance or a Instance <#openstack.database.v1.instance.Instance>
database — the value can be the ID of a database or a Database <#openstack.database.v1.database.Database> instance.

Returns: one Database 🗄️

Raises NotFoundException when no resource can be found. yeah — if it's not there, it really isn't there, no cap 😭

🍨 Flavor Operations

The flavor corner of the proxy, bestie. Same class, same everything:

class openstack.database.v1._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

find_flavor(name_or_id, ignore_missing=True)

Find a single flavor 🔍 like, just one. the one. periodt.

Parameters

name_or_id — The name or ID of a flavor.
ignore_missing — When set to False, NotFoundException will be raised when the resource does not exist. When set to True, None will be returned when attempting to find a nonexistent resource. so like… ghost it or catch feelings, your call 💅

Returns: One Flavor or None

get_flavor(flavor)

Get a single flavor ✨

Parameters

flavor — The value can be the ID of a flavor or a Flavor instance.

Returns: One Flavor

Raises NotFoundException when no resource can be found. she's not here, bestie 🫶

flavors(**query)

Return a generator of flavors 🌈 yes, a generator, not a list — she's lazy in the efficient way, not the toxic way.

Parameters

query — Optional query parameters to be sent to limit the resources being returned.

Returns: A generator of flavor objects

🧚 Instance Operations

Now the main character section — instances, the whole reason you're here tbh 👑

class openstack.database.v1._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

create_instance(**attrs)

Create a new instance from attributes 🐣 it's giving birth-of-a-database energy.

Parameters

attrs — Keyword arguments which will be used to create a Instance, comprised of the properties on the Instance class.

Returns: The results of server creation

delete_instance(instance, ignore_missing=True)

Delete an instance 💀 gone. reduced to atoms. respectfully.

Parameters

instance — The value can be either the ID of an instance or a Instance instance.
ignore_missing — When set to False, NotFoundException will be raised when the instance does not exist. When set to True, no exception will be set when attempting to delete a nonexistent instance. so like, unbothered. moisturized. in her lane ✨

Returns: None

find_instance(name_or_id, ignore_missing=True)

Find a single instance 🔎

Parameters

name_or_id — The name or ID of a instance.
ignore_missing — When set to False, NotFoundException will be raised when the resource does not exist. When set to True, None will be returned when attempting to find a nonexistent resource.

Returns: One Instance or None

get_instance(instance)

Get a single instance 🌸

Parameters

instance — The value can be the ID of an instance or a Instance instance.

Returns: One Instance

Raises NotFoundException when no resource can be found. 😭

instances(**query)

Return a generator of instances 🌟

Parameters

query — Optional query parameters to be sent to limit the resources being returned.

Returns: A generator of instance objects

update_instance(instance, **attrs)

Update a instance ✏️ glow-up time, we love a transformation arc.

Parameters

instance — Either the id of a instance or a Instance instance.
attrs — The attributes to update on the instance represented by instance.

Returns: The updated instance

🎀 User Operations

And finally the users section — the little guys who actually log in 🫶 database users, not like, your ex. different thing.

class openstack.database.v1._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

create_user(instance, **attrs)

Create a new user from attributes 🧑‍💻 new account, who dis

Parameters

instance — This can be either the ID of an instance or a Instance
attrs — Keyword arguments which will be used to create a User, comprised of the properties on the User class.

Returns: The results of server creation

delete_user(user, instance=None, ignore_missing=True)

Delete a user 🗑️ bye bestie, block and delete, the whole routine.

Parameters

user — The value can be either the ID of a user or a User instance.
instance — This parameter needs to be specified when an ID is given as user. It can be either the ID of an instance or a Instance
ignore_missing — When set to False, NotFoundException will be raised when the user does not exist. When set to True, no exception will be set when attempting to delete a nonexistent user.

⚠️ lowkey important: if you're passing an ID as user, you must also pass instance. no instance, no vibes, no deletion. iykyk 💅

Returns: None

find_user(name_or_id, instance, ignore_missing=True)

Find a single user 🔍 note that unlike delete_user, instance here is required — no default, she's not optional. main character energy fr.

Parameters

name_or_id — The name or ID of a user.
instance — This can be either the ID of an instance or a Instance
ignore_missing — When set to False, NotFoundException will be raised when the resource does not exist. When set to True, None will be returned when attempting to find a nonexistent resource.

Returns: One User or None

users(instance, **query)

Return a generator of users 🌈💖

Parameters

instance — This can be either the ID of an instance or a Instance
query — Optional query parameters to be sent to limit the resources being returned.

Returns: A generator of user objects

get_user(user, instance=None)

Get a single user ⭐

Parameters

user — The value can be the ID of a user or a User instance.
instance — This parameter needs to be specified when an ID is given as database. It can be either the ID of an instance or a Instance

🙈 and yes, the original docstring literally says database there even though the parameter is instance. we're reporting it exactly as written, character for character — not my typo, i'm just the messenger 🫡

Returns — one User (fr the openstack.database.v1.user.User one 💅)

Raises — NotFoundException (that's openstack.exceptions.NotFoundException) when no resource can be found, no cap. 😭

🦋 DNS API

For the full glow-up on how to actually use dns, peep Using OpenStack DNS.

🌸 The DNS Class

Okay so the dns high-level interface lives on the dns member of a Connection object. Iconic. But heads up bestie: that dns member is only added if the service is detected — no service, no member, that's just how it is. 🫶

🎀 DNS Zone Operations

Here's the whole constructor, exactly as-is, because we do not paraphrase signatures in this house:

class openstack.dns.v2._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

💜 `zones(**query)`

Retrieve a generator of zones — yes, a generator, so it's lazy and cute like that. ✨

Parameters

query — optional query params you can send to limit which resources come back:
- name: Zone Name field.
- type: Zone Type field.
- email: Zone email field.
- status: Status of the zone.
- ttl: TTL field filter.abs
- description: Zone description field filter.

Returns — a generator of zone Zone instances (the openstack.dns.v2.zone.Zone kind 🦋).

`create_zone(**attrs)`

Create a brand new zone from attributes. Main character energy for your DNS. 👑

Parameters

attrs — keyword arguments used to create a Zone (openstack.dns.v2.zone.Zone), made up of the properties on the Zone class.

Returns — the results of zone creation.

`get_zone(zone)`

Get a zone. Simple. Slay. 💅

Parameters

zone — the value can be the ID of a zone or a Zone (openstack.dns.v2.zone.Zone) instance.

Returns — a Zone instance.

`delete_zone(zone, ignore_missing=True, delete_shares=False)`

Delete a zone. Bye bestie 👋😭

Parameters

zone — the value can be the ID of a zone or a Zone (openstack.dns.v2.zone.Zone) instance.
ignore_missing — when set to False, NotFoundException (openstack.exceptions.NotFoundException) will be raised when the zone does not exist. When set to True, no exception will be set when attempting to delete a nonexistent zone.
delete_shares — when True, delete the zone shares along with the zone.

Returns — Zone been deleted.

`find_zone(name_or_id, ignore_missing=True)`

Find a single zone — like a search but for exactly one, we love a monogamous lookup. 🔍

Parameters

name_or_id — the name or ID of a zone.
ignore_missing — when set to False, NotFoundException (openstack.exceptions.NotFoundException) will be raised when the zone does not exist. When set to True, no exception will be set when attempting to delete a nonexistent zone.

Returns — Zone (openstack.dns.v2.zone.Zone).

`abandon_zone(zone, **attrs)`

Abandon Zone 🫥 (yes that's really the name, it's giving "walking away dramatically").

Parameters

zone — the value can be the ID of a zone to be abandoned or a ZoneExport (openstack.dns.v2.zone_export.ZoneExport) instance.

Returns — None.

`xfr_zone(zone, **attrs)`

Trigger update of a secondary Zone. Go off, trigger it. 🔥

Parameters

zone — the value can be the ID of a zone to be abandoned or a ZoneExport (openstack.dns.v2.zone_export.ZoneExport) instance.

Returns — None.

⭐ Recordset Operations

Same constructor, same everything, here it is again verbatim because it belongs to this section too:

class openstack.dns.v2._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

🎀 `recordsets(zone=None, **query)`

Retrieve a generator of recordsets. Generators keep giving, iykyk. ✨

Parameters

zone — the optional value can be the ID of a zone or a Zone (openstack.dns.v2.zone.Zone) instance. If it is not given, all recordsets for all zones of the tenant would be retrieved.
query — optional query params sent to limit the resources being returned:
- name: Recordset Name field.
- type: Type field.
- status: Status of the recordset.
- ttl: TTL field filter.
- description: Recordset description field filter.

Returns — a generator of zone (Recordset, i.e. openstack.dns.v2.recordset.Recordset) instances.

`create_recordset(zone, **attrs)`

Create a new recordset in the zone. Nesting it right in there. 🪆

Parameters

zone — the value can be the ID of a zone or a Zone (openstack.dns.v2.zone.Zone) instance.
attrs — keyword arguments used to create a Recordset (openstack.dns.v2.recordset.Recordset), made up of the properties on the Recordset class.

Returns — the results of zone creation.

`update_recordset(recordset, **attrs)`

Update Recordset attributes. Glow-up arc unlocked. 💖

Parameters

attrs — keyword arguments used to create a Recordset (openstack.dns.v2.recordset.Recordset), made up of the properties on the Recordset class.

Returns — the results of zone creation.

`get_recordset(recordset, zone)`

Get a recordset. One (1) recordset, coming right up. 🍓

Parameters

zone — the value can be the ID of a zone or a Zone (openstack.dns.v2.zone.Zone) instance.
recordset — the value can be the ID of a recordset or a Recordset (openstack.dns.v2.recordset.Recordset) instance.

Returns — Recordset instance.

`delete_recordset(recordset, zone=None, ignore_missing=True)`

Delete a zone — yes, the label literally says zone, we're not fixing it, we're just reporting it. 🙈

Parameters

recordset — the value can be the ID of a recordset or a Recordset (openstack.dns.v2.recordset.Recordset) instance.
zone — the value can be the ID of a zone or a Zone (openstack.dns.v2.zone.Zone) instance.
ignore_missing — when set to False, NotFoundException (openstack.exceptions.NotFoundException) will be raised when the zone does not exist. When set to True, no exception will be set when attempting to delete a nonexistent zone.

Returns — Recordset instance been deleted.

🌈 Zone Import Operations

And once more, the constructor, character for character, because it's a whole vibe:

class openstack.dns.v2._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

🧚 `zone_imports(**query)`

Retrieve a generator of zone imports — bringing zones in from elsewhere, very "new era" of you. ⭐

Parameters

query — optional query params you can send to limit the resources being returned:
- zone_id: Zone I field.
- message: Message field.
- status: Status of the zone import record.

Returns — a generator of zone ZoneImport instances (that's openstack.dns.v2.zone_import.ZoneImport 🦋).

`create_zone_import(**attrs)`

Create a new zone import from attributes. Fresh import, fresh start, periodt. 💅

Parameters

attrs — keyword arguments used to create a ZoneImport (openstack.dns.v2.zone_import.ZoneImport), made up of the properties on the ZoneImport class.

Returns — the results of zone creation ✨ that's the whole return value, no cap.

`get_zone_import(zone_import)`

Grab a single zone import record 💖

zone_import — the value can be the ID of a zone import or a ZoneImport <#openstack.dns.v2.zone_import.ZoneImport> instance.

Returns — a ZoneImport instance.

`delete_zone_import(zone_import, ignore_missing=True)`

Delete a zone import 🗑️

zone_import — the value can be the ID of a zone import or a ZoneImport <#openstack.dns.v2.zone_import.ZoneImport> instance.
ignore_missing — when set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the zone does not exist. When set to True, no exception will be set when attempting to delete a nonexistent zone.

Returns — the deleted zone import.

🦋 Zone Export Operations

class openstack.dns.v2._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

`zone_exports(**query)`

Hands you back a generator of zone exports 🌈 (yes, a generator — lazy, iconic, main-character energy)

query — optional query parameters to be sent to limit the resources being returned.
- zone_id: Zone I field.
- message: Message field.
- status: Status of the zone import record.

Returns — a generator of zone ZoneExport <#openstack.dns.v2.zone_export.ZoneExport> instances.

`create_zone_export(zone, **attrs)`

Make a brand-new zone export from attributes 💅

zone — the value can be the ID of a zone to be exported or a ZoneExport <#openstack.dns.v2.zone_export.ZoneExport> instance.
attrs — keyword arguments which will be used to create a ZoneExport <#openstack.dns.v2.zone_export.ZoneExport>, comprised of the properties on the ZoneExport class.

Returns — the results of zone creation.

`get_zone_export(zone_export)`

Get one zone export record 🎀

zone — the value can be the ID of a zone import or a ZoneExport <#openstack.dns.v2.zone_export.ZoneExport> instance.

Returns — ZoneExport instance.

`get_zone_export_text(zone_export)`

Get a zone export record, but as text 📄 (same data, text-flavored vibe)

zone — the value can be the ID of a zone import or a ZoneExport <#openstack.dns.v2.zone_export.ZoneExport> instance.

Returns — ZoneExport instance.

`delete_zone_export(zone_export, ignore_missing=True)`

Yeet a zone export 🗑️✨

zone_export — the value can be the ID of a zone import or a ZoneExport <#openstack.dns.v2.zone_export.ZoneExport> instance.
ignore_missing — when set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the zone does not exist. When set to True, no exception will be set when attempting to delete a nonexistent zone.

Returns — the deleted zone export.

🌸 FloatingIP Operations

class openstack.dns.v2._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

`floating_ips(**query)`

Retrieve a generator of recordsets 🫶

query — optional query parameters to be sent to limit the resources being returned.
- name: Recordset Name field.
- type: Type field.
- status: Status of the recordset.
- ttl: TTL field filter.
- description: Recordset description field filter.

Returns — a generator of floatingips (FloatingIP <#openstack.dns.v2.floating_ip.FloatingIP>) instances.

`get_floating_ip(floating_ip)`

Get a Floating IP 💖

floating_ip — the value can be the ID of a floating ip or a FloatingIP <#openstack.dns.v2.floating_ip.FloatingIP> instance. The ID is in format "region_name:floatingip_id".

Returns — FloatingIP instance.

`update_floating_ip(floating_ip, **attrs)`

Update floating ip attributes ✨

floating_ip — the id or an instance of FloatingIP.
attrs — attributes for update on FloatingIP.

👑 TLD Operations

class openstack.dns.v2._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

`tlds(**query)`

Retrieve a generator of tlds 🌐

query — optional query parameters to be sent to limit the resources being returned.
- name: TLD Name field.

Returns — a generator of tld TLD <#openstack.dns.v2.tld.TLD> instances.

`create_tld(**attrs)`

Create a new tld from attributes 🎀

attrs — keyword arguments which will be used to create a TLD <#openstack.dns.v2.tld.TLD>, comprised of the properties on the TLD class.

Returns — the results of TLD creation.

`get_tld(tld)`

Get a tld 🔍

tld — the value can be the ID of a tld or a TLD <#openstack.dns.v2.tld.TLD> instance.

Returns — tld instance.

`delete_tld(tld, ignore_missing=True)`

Delete a tld 💀

tld — the value can be the ID of a tld or a TLD <#openstack.dns.v2.tld.TLD> instance.
ignore_missing — when set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the tld does not exist. When set to True, no exception will be set when attempting to delete a nonexistent tld.

Returns — TLD been deleted.

`find_tld(name_or_id, ignore_missing=True)`

Find a single tld 🧚

name_or_id — the name or ID of a tld.
ignore_missing — when set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the tld does not exist. When set to True, no exception will be set when attempting to delete a nonexistent tld.

Returns — TLD <#openstack.dns.v2.tld.TLD>.

⭐ Zone Transfer Operations

class openstack.dns.v2._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

zone_transfer_requests(**query) — grab a generator of all the zone transfer requests ✨

Parameters

query — optional query params you can send to filter down what comes back:

status: the status of the recordset.

Returns

A generator of transfer requests — ZoneTransferRequest <#openstack.dns.v2.zone_transfer.ZoneTransferRequest> instances, bestie 🫶

get_zone_transfer_request(request) — pull the info for one ZoneTransfer Request 🔍

Parameters

request — can be the ID of a transfer request, or a ZoneTransferRequest <#openstack.dns.v2.zone_transfer.ZoneTransferRequest> instance. Either works, no cap.

Returns

A zone transfer request instance.

create_zone_transfer_request(zone, **attrs) — make a fresh ZoneTransfer Request out of attributes 🌱

Parameters

zone — can be the ID of a zone you wanna transfer, or a ZoneExport <#openstack.dns.v2.zone_export.ZoneExport> instance.
attrs — keyword args used to create the ZoneTransferRequest <#openstack.dns.v2.zone_transfer.ZoneTransferRequest>, made up of the properties on the ZoneTransferRequest class.

Returns

The results of zone transfer request creation.

update_zone_transfer_request(request, **attrs) — change up the attributes on a ZoneTransfer Request 💅

Parameters

floating_ip — the id or an instance of ZoneTransferRequest <#openstack.dns.v2.zone_transfer.ZoneTransferRequest>. (yes, the param is literally called floating_ip in this doc, we don't ask questions 🫠)
attrs — attributes to update on the ZoneTransferRequest <#openstack.dns.v2.zone_transfer.ZoneTransferRequest>.

delete_zone_transfer_request(request, ignore_missing=True) — yeet a ZoneTransfer Request 💀

Parameters

request — can be the ID of a zone transfer request, or a ZoneTransferRequest <#openstack.dns.v2.zone_transfer.ZoneTransferRequest> instance.
ignore_missing — when set to False, NotFoundException <#openstack.exceptions.NotFoundException> gets raised when the zone doesn't exist. When set to True, no exception is set when you try to delete a nonexistent zone.

Returns

The deleted zone transfer request.

zone_transfer_accepts(**query) — get a generator of zone transfer accepts ✨

Parameters

query — optional query params to send to limit the resources returned:

status: the status of the recordset.

Returns

A generator of transfer accepts — ZoneTransferAccept <#openstack.dns.v2.zone_transfer.ZoneTransferAccept> instances.

get_zone_transfer_accept(accept) — get the info for one ZoneTransfer Accept 🔎

Parameters

request — can be the ID of a transfer accept, or a ZoneTransferAccept <#openstack.dns.v2.zone_transfer.ZoneTransferAccept> instance. (yeah the param is listed as request even tho the arg is accept — that's literally what it says, iykyk 🙈)

Returns

A zone transfer request instance.

create_zone_transfer_accept(**attrs) — make a brand new ZoneTransfer Accept from attributes 🎀

Parameters

attrs — keyword args used to create the ZoneTransferAccept <#openstack.dns.v2.zone_transfer.ZoneTransferAccept>, comprised of the properties on the ZoneTransferAccept class.

Returns

The results of zone transfer request creation.

class openstack.dns.v2._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

zone_shares(zone, **query) — get a generator of zone shares 💖

Parameters

zone — the zone ID or a Zone <#openstack.dns.v2.zone.Zone> instance.
query — optional query params to send to limit the resources returned:
- target_project_id: the target project ID field.

Returns

A generator of zone shares — ZoneShare <#openstack.dns.v2.zone_share.ZoneShare> instances.

get_zone_share(zone, zone_share) — get one zone share 🔍

Parameters

zone — can be the ID of a zone or a Zone <#openstack.dns.v2.zone.Zone> instance.
zone_share — can be either the ID of the zone share, or a ZoneShare <#openstack.dns.v2.zone_share.ZoneShare> instance that the zone share belongs to.

Returns

A ZoneShare instance.

find_zone_share(zone, zone_share_id, ignore_missing=True) — find a single zone share 🦋

Parameters

zone — can be the ID of a zone or a Zone <#openstack.dns.v2.zone.Zone> instance.
zone_share_id — the zone share ID.
ignore_missing — when set to False, NotFoundException <#openstack.exceptions.NotFoundException> gets raised when the zone share doesn't exist. When set to True, None is returned when you try to find a nonexistent zone share.

Returns

ZoneShare <#openstack.dns.v2.zone_share.ZoneShare>

create_zone_share(zone, **attrs) — create a new zone share from attributes 🌱

Parameters

zone — the zone ID or a Zone <#openstack.dns.v2.zone.Zone> instance.
attrs — keyword args used to create a ZoneShare <#openstack.dns.v2.zone_share.ZoneShare>, comprised of the properties on the ZoneShare class.

Returns

The results of zone share creation.

delete_zone_share(zone, zone_share, ignore_missing=True) — delete a zone share 💀

Parameters

zone — the zone ID or a Zone <#openstack.dns.v2.zone.Zone> instance.
zone_share — can be either the ID of the zone share, or a ZoneShare <#openstack.dns.v2.zone_share.ZoneShare> instance that the zone share belongs to.
ignore_missing — when set to False, NotFoundException <#openstack.exceptions.NotFoundException> gets raised when the zone share doesn't exist. When set to True, no exception is set when you try to delete a nonexistent zone share.

Returns

None

✨ Limit Operations ✨

class openstack.dns.v2._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

limits(**query) — get a generator of limits 👑

Returns

A generator of limits — Limit <#openstack.dns.v2.limit.Limit> instances.

🎀 Quota Operations 🎀

class openstack.dns.v2._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

quotas(**query) — returns a generator of quotas 💜

Parameters

query — optional query params you send to limit the resources being returned.

-a, --all — bestie this is the one that shows you everything, no filter, no cap 💅
-n, --number — ok so this one's giving "numbered list" energy, it literally adds line numbers to the output ✨
-s, --squeeze-blank — the way this one just smooths things out... it collapses multiple blank lines into a single one, iconic behavior honestly 🎀
-u, --unbuffered — no buffering, no waiting, just immediately pushing output through. it's giving impatient main character energy fr fr 💀

🌸 Service Status Operations 🌸

okay so check it — this is literally the same Proxy class definition again, same constructor, same everything:

class openstack.dns.v2._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

`service_statuses()`

Retrieve a generator of service statuses — like, it hands you back a generator that spits out all the service statuses one at a time 🦋

Returns — a generator of service statuses, specifically ServiceStatus <#openstack.dns.v2.service_status.ServiceStatus> instances. so you get all the tea about what's up with each service 💖

`get_service_status(service)`

Get a status of a service in the Designate system — this one's your lookup tool, you give it a service and it tells you what's going on with it 🔍

service — so this can be either the ID of a service OR a ServiceStatus <#openstack.dns.v2.service_status.ServiceStatus> instance. like, you can pass it the actual object or just the ID, either way works bestie ✨
Returns — a ServiceStatus instance. periodt. 👑

💀 Blacklist Operations 💀

again, same Proxy class, same constructor, we're literally just copy-pasting the vibe at this point:

class openstack.dns.v2._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

`blacklists(**query)`

Retrieve a generator of blacklists — so like, this one's giving you a generator of all the blacklist entries 🚫

Returns — a generator of Blacklist <#openstack.dns.v2.blacklist.Blacklist> instances. so you get them one by one, very chill, very on-demand 💅

`get_blacklist(blacklist)`

Get a blacklist — singular. one. single. blacklist. 🎯

blacklist — the value can be either the ID of a blacklist OR a Blacklist <#openstack.dns.v2.blacklist.Blacklist> instance. like, pass it whatever you got bestie 🫶
Returns — a Blacklist instance. simple as that. no cap. 💖

`create_blacklist(**attrs)`

Create a new blacklist — you're making a brand new one, main character energy fr fr ✨

attrs — these are keyword arguments that'll be used to create a Blacklist <#openstack.dns.v2.blacklist.Blacklist>. they're comprised of the properties on the Blacklist class, so like, you're just passing in the ingredients and it bakes you a blacklist 🧚
Returns — the results of blacklist creation. so like, the new blacklist that you just made. slay. 🔥

`update_blacklist(blacklist, **attrs)`

Update blacklist attributes — you're changing stuff on an existing one, giving it a little makeover 💅

blacklist — the id or an instance of ~openstack.dns.v2.blacklist.Blacklist. so like, whatever you got, it'll take it 🎀
attrs — attributes for update on ~openstack.dns.v2.blacklist.Blacklist. these are the ones you're changing, bestie 🌸
Returns — the updated blacklist. so like, here's the glow-up, looking fresh 💖

`delete_blacklist(blacklist, ignore_missing=True)`

Delete a blacklist — bye bye 👋 it's giving "you're not coming to the function anymore" energy 💀

blacklist — the id or an instance of ~openstack.dns.v2.blacklist.Blacklist. same deal, ID or object, either works 🦋
ignore_missing — okay so this one's important bestie. when set to False, a NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the blacklist does not exist. but when set to True (which is the default!), no exception will be set when attempting to delete a nonexistent blacklist. so like, if you're not sure it's there, leave this as True and it'll just quietly do its thing 🤫
Returns — the blacklist that's been deleted. like, here's what got yeeted 🗑️

🌈 Identity API v2 🌈

okay so for the details on how to use identity, you gotta see Using OpenStack Identity <>. that's your homework bestie, go read it 📚

🎀 The Identity v2 Class 🎀

the identity high-level interface is available through the identity member of a Connection <#openstack.connection.Connection> object. so like, you access it through the connection, iykyk 💅

important note: the identity member will only be added if the service is detected. so like, if it's not there, it's not there. no vibes to be had 💀

✨ Extension Operations ✨

okay so we're back with another Proxy class definition, same constructor arguments, same everything:

class openstack.identity.v2._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

`extensions()`

Retrieve a generator of extensions — it's giving you all the extensions, one at a time, very chill 🦋

Returns — a generator of extension instances. so like, a whole stream of them 💖

`get_extension(extension)`

Get a single extension — just one. singular. focused. 🎯

extension — the value can be either the ID of an extension OR an Extension <#openstack.identity.v2.extension.Extension> instance. so like, pass whatever you have bestie ✨
Returns — one Extension <#openstack.identity.v2.extension.Extension>. periodt. 💅
Raises — NotFoundException <#openstack.exceptions.NotFoundException> when no extension can be found. so like, if it doesn't exist, you're getting an exception, no cap 😭

👑 User Operations 👑

and again, same Proxy class, same constructor, we're literally just going through the motions at this point:

class openstack.identity.v2._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

`create_user(**attrs)`

Create a new user from attributes — you're making a whole new user, main character energy fr fr 🔥

attrs — keyword arguments which will be used to create a User <#openstack.identity.v2.user.User>, comprised of the properties on the User class. so like, you're just passing in all the deets and it creates the user for you 🧚
Returns — the results of user creation. so like, the new user, fresh out the oven 💖

`delete_user(user, ignore_missing=True)`

Delete a user — bye bestie 👋 you're gone, you're out, no more vibes from you 💀

user — the value can be either the ID of a user OR a User <#openstack.identity.v2.user.User> instance. same deal as always, ID or object 🦋
ignore_missing — okay so when set to False, a NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the user does not exist. but when set to True (the default!), no exception will be set when attempting to delete a nonexistent user. so like, it just quietly does nothing if they're already gone 🤫
Returns — None. that's it. nothing. nada. silence. 💅

`find_user(name_or_id, ignore_missing=True)`

Find a single user — you're looking for one specific user, giving detective energy 🔍

name_or_id — the name or ID of a user. so like, you can search by either one, very flexible bestie ✨
ignore_missing — when set to False, a NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the resource does not exist. but when set to True (default!), None will be returned when attempting to find a nonexistent resource. so like, if you're not sure they're there, you'll just get None back, no drama 🎀
Returns — one User <#openstack.identity.v2.user.User> or None. so like, either you found them or you didn't, no in-between 💖

`get_user(user)`

Get a single user — again, just one, focused, singular, no cap 🎯

So like, wrapping up get_user real quick:

Parameters
- user — the value can be the ID of a user or a User (#openstack.identity.v2.user.User) instance. 💖
Returns — One User (#openstack.identity.v2.user.User). ✨
Raises — NotFoundException (#openstack.exceptions.NotFoundException) when no resource can be found. 😭 Like, it's just not there bestie, no cap.

`users(**query)`

Retrieve a generator of users. 🔥 Yes, a generator — it's giving lazy iterator energy, she doesn't dump everything on you at once.

Parameters
- query — optional query parameters that get sent along to limit the resources being returned. 🎀
Returns — a generator of user instances. Slay.

`update_user(user, **attrs)`

Update a user. Glow-up time. 💅

Parameters
- user — either the ID of a user or a User (#openstack.identity.v2.user.User) instance. 🫶
- attrs — the attributes you're updating on the user represented by user.
Returns — the updated user. Iconic.

🎭 Role Operations

class openstack.identity.v2._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

Look at that constructor. It's giving "I have a lot of kwargs and I'm not sorry." 💀 Every single one is up there in the block above, verbatim, don't come for me.

`create_role(**attrs)`

Create a new role from attributes. New role, who dis? 👑

Parameters
- attrs — keyword arguments that'll be used to create a Role (#openstack.identity.v2.role.Role), made up of the properties on the Role class. 🦋
Returns — the results of role creation.

`delete_role(role, ignore_missing=True)`

Delete a role. Bye bestie 👋

Parameters
- role — the value can be either the ID of a role or a Role (#openstack.identity.v2.role.Role) instance.
- ignore_missing — when it's set to False, NotFoundException (#openstack.exceptions.NotFoundException) gets raised when the role does not exist. When it's set to True, no exception gets set when you attempt to delete a nonexistent role. 🙈 (Lowkey the forgiving mode, fr.)
Returns — None.

`find_role(name_or_id, ignore_missing=True)`

Find a single role. Detective mode 🕵️‍♀️✨

Parameters
- name_or_id — the name or ID of a role.
- ignore_missing — when it's set to False, NotFoundException (#openstack.exceptions.NotFoundException) gets raised when the resource does not exist. When it's set to True, None gets returned when you attempt to find a nonexistent resource. 😌
Returns — One Role (#openstack.identity.v2.role.Role) or None.

`get_role(role)`

Get a single role. Gimme gimme 🫴

Parameters
- role — the value can be the ID of a role or a Role (#openstack.identity.v2.role.Role) instance.
Returns — One Role (#openstack.identity.v2.role.Role).
Raises — NotFoundException (#openstack.exceptions.NotFoundException) when no resource can be found. 😭

`roles(**query)`

Retrieve a generator of roles. ⭐

Parameters
- query — optional query parameters to be sent to limit the resources being returned.
Returns — a generator of role instances.

`update_role(role, **attrs)`

Update a role. She's evolving 💫

Parameters
- role — either the ID of a role or a Role (#openstack.identity.v2.role.Role) instance.
- attrs — the attributes to update on the role represented by role.
Returns — the updated role.

🏠 Tenant Operations

class openstack.identity.v2._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

Same constructor, same absolute wall of kwargs — copied exactly, every default and all. 💜

`create_tenant(**attrs)`

Create a new tenant from attributes. New tenant just dropped 🎀

Parameters
- attrs — keyword arguments which will be used to create a Tenant (#openstack.identity.v2.tenant.Tenant), comprised of the properties on the Tenant class.
Returns — the results of tenant creation.

`delete_tenant(tenant, ignore_missing=True)`

Delete a tenant. 🧹

Parameters
- tenant — the value can be either the ID of a tenant or a Tenant (#openstack.identity.v2.tenant.Tenant) instance.
- ignore_missing — when set to False, NotFoundException (#openstack.exceptions.NotFoundException) will be raised when the tenant does not exist. When set to True, no exception will be set when attempting to delete a nonexistent tenant. 🙈
Returns — None.

`find_tenant(name_or_id, ignore_missing=True)`

Find a single tenant. 🔍

Parameters
- name_or_id — the name or ID of a tenant.
- ignore_missing — when set to False, NotFoundException (#openstack.exceptions.NotFoundException) will be raised when the resource does not exist. When set to True, None will be returned when attempting to find a nonexistent resource. ✨
Returns — One Tenant (#openstack.identity.v2.tenant.Tenant) or None.

`get_tenant(tenant)`

Get a single tenant. Gimme 😤

Parameters
- tenant — the value can be the ID of a tenant or a Tenant (#openstack.identity.v2.tenant.Tenant) instance.
Returns — One Tenant (#openstack.identity.v2.tenant.Tenant).
Raises — NotFoundException (#openstack.exceptions.NotFoundException) when no resource can be found. 😭

`tenants(**query)`

Retrieve a generator of tenants. 🌸

Parameters
- query — optional query parameters to be sent to limit the resources being returned.
Returns — a generator of tenant instances.

`update_tenant(tenant, **attrs)`

Update a tenant. ✨

Parameters
- tenant — either the ID of a tenant or a Tenant (#openstack.identity.v2.tenant.Tenant) instance.
- attrs — the attributes to update on the tenant represented by tenant.
Returns — the updated tenant.

🌈 Identity API v3

For details on how to use identity, see Using OpenStack Identity <>. (Yes, that's the literal reference as written — I'm not out here inventing links, bestie. 🫶)

💫 The Identity v3 Class

The identity high-level interface is available through the identity member of a Connection (#openstack.connection.Connection) object. The identity member will only be added if the service is detected. ✨ Like, she only shows up if she's invited.

🎀 Credential Operations

class openstack.identity.v3._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

v3 proxy, same giant kwargs list, verbatim, character for character. 👑

`create_credential(**attrs)`

Create a new credential from attributes. 🔐

Parameters
- attrs — keyword arguments which will be used to create a Credential (#openstack.identity.v3.credential.Credential), comprised of the properties on the Credential class.
Returns — the results of credential creation.

`delete_credential(credential, ignore_missing=True)`

Delete a credential. 🗑️

Parameters
- credential — the value can be either the ID of a credential or a Credential (#openstack.identity.v3.credential.Credential) instance.
ignore_missing — bestie, this is the drama switch 🎀 when it's False, a NotFoundException <#openstack.exceptions.NotFoundException> gets raised the second the credential doesn't exist. When it's True, literally nothing happens — no exception gets set when you try to delete a credential that was never there. ghosted, respectfully 💅

Returns

None

🌸 `find_credential(name_or_id, ignore_missing=True)`

Find one single credential. just the one. we're not greedy ✨

Parameters

name_or_id — the name or the ID of a credential, either works, iykyk.
ignore_missing — when it's False, a NotFoundException <#openstack.exceptions.NotFoundException> gets raised if the resource doesn't exist. when it's True, you just get None back when you go looking for something that isn't there. no cap, very chill of it 🦋

Returns

One Credential <#openstack.identity.v3.credential.Credential> or None

💜 `get_credential(credential)`

Get a single credential. the getting-est of them all 👑

Parameters

credential — the value can be the ID of a credential or a Credential <#openstack.identity.v3.credential.Credential> instance. your choice, main character 🌈

Returns

One Credential <#openstack.identity.v3.credential.Credential>

Raises NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found. 😭

🦋 `credentials(**query)`

Retrieve a generator of credentials. a whole little stream of them, iconic 💫

Parameters

query — optional query parameters, sent along to limit the resources being returned. basically "here's what I want, filter accordingly" 💅

Returns

A generator of credentials instances.

🎀 `update_credential(credential, **attrs)`

Update a credential. glow-up time ✨

Parameters

credential — either the ID of a credential or a Credential <#openstack.identity.v3.credential.Credential> instance.
attrs — the attributes to update on the credential represented by credential. sprinkle sprinkle 🧚

Returns

The updated credential

👑 Domain Operations 👑

class openstack.identity.v3._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

like, that is the whole constructor signature and I am not about to paraphrase it. it's giving very "read it and weep" energy 💀 every kwarg stays, fr fr.

⭐ `create_domain(**attrs)`

Create a brand new domain from attributes. fresh out the box 🎁

Parameters

attrs — keyword arguments which will be used to create a Domain <#openstack.identity.v3.domain.Domain>, comprised of the properties on the Domain class.

Returns

The results of domain creation

💖 `delete_domain(domain, ignore_missing=True)`

Delete a domain. gone, bye, slay 🫶

Parameters

domain — the value can be either the ID of a domain or a Domain <#openstack.identity.v3.domain.Domain> instance.
ignore_missing — when it's False, a NotFoundException <#openstack.exceptions.NotFoundException> gets raised if the domain doesn't exist. when it's True, no exception gets set when you try to delete a domain that never existed. we love a graceful exit 💅

Returns

None

🔥 `find_domain(name_or_id, ignore_missing=True)`

Find a single domain. detective mode 🔍

Parameters

name_or_id — the name or ID of a domain.
ignore_missing — set it to False and a NotFoundException <#openstack.exceptions.NotFoundException> gets raised when the resource doesn't exist. set it to True and you get None back when you go hunting for a nonexistent resource. choosing peace, honestly 🌸

Returns

One Domain <#openstack.identity.v3.domain.Domain> or None

💜 `get_domain(domain)`

Get a single domain. just the one. periodt 👑

Parameters

domain — the value can be the ID of a domain or a Domain <#openstack.identity.v3.domain.Domain> instance.

Returns

One Domain <#openstack.identity.v3.domain.Domain>

Raises NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found. 😭

🌈 `domains(**query)`

Retrieve a generator of domains. a whole parade of them 🎉

Parameters

query — optional query parameters to be sent to limit the resources being returned.

Returns

A generator of domain instances.

✨ `update_domain(domain, **attrs)`

Update a domain. the glow-up continues 💫

Parameters

domain — either the ID of a domain or a Domain <#openstack.identity.v3.domain.Domain> instance.
attrs — the attributes to update on the domain represented by domain.

Returns

The updated domain

🎀 Domain Config Operations 🎀

class openstack.identity.v3._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

same signature, same energy, we are not re-typing our feelings about it 💀

🍓 `create_domain_config(domain, **attrs)`

Create a new config for a domain from attributes. cute little config baby 🧚

Parameters

domain — the value can be the ID of a domain or a Domain <#openstack.identity.v3.domain.Domain> instance.
attrs — keyword arguments which will be used to create a DomainConfig <#openstack.identity.v3.domain_config.DomainConfig> comprised of the properties on the DomainConfig class.

Returns

The results of domain config creation

🦋 `delete_domain_config(domain, ignore_missing=True)`

Delete a config for a domain. bye config 💅

Parameters

domain — the value can be the ID of a domain or a a Domain <#openstack.identity.v3.domain.Domain> instance.
ignore_missing — when it's False, a NotFoundException <#openstack.exceptions.NotFoundException> gets raised when the identity provider doesn't exist. when it's True, no exception gets set when you attempt to delete a nonexistent config for a domain. 🫶

👀 ok so heads up: yes, the original really does say "the identity provider does not exist" in a domain-config method. not a typo I made, not me being chaotic — copying it faithfully, bestie. don't shoot the messenger 💀

Returns

None

🌸 `get_domain_config(domain)`

Get a single config for a domain.

Parameters

domain_id — the value can be the ID of a domain or a Domain <#openstack.identity.v3.domain.Domain> instance.

Returns

One DomainConfig <#openstack.identity.v3.domain_config.DomainConfig>

Raises NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found. 😭

⭐ `update_domain_config(domain, **attrs)`

Update a config for a domain. glow-up, config edition ✨

Parameters

domain_id — the value can be the ID of a domain or a Domain <#openstack.identity.v3.domain.Domain> instance.
attrs — the attributes to update on the config for a domain represented by domain_id.

Returns

The updated config for a domain

💜 Endpoint Operations 💜

class openstack.identity.v3._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

yes it's the same giant kwargs list again. it's giving "copy-paste but make it ✨documentation✨" 🌈

🔥 `create_endpoint(**attrs)`

Create a new endpoint from attributes. new endpoint just dropped 👑

Parameters

attrs — keyword arguments which will be used to create a Endpoint <#openstack.identity.v3.endpoint.Endpoint>, comprised of the properties on the Endpoint class.

Returns: The results of endpoint creation ✨

delete_endpoint(endpoint, ignore_missing=True) — Delete an endpoint 💅
- Parameters:
  - endpoint — The value can be either the ID of an endpoint or a Endpoint <#openstack.identity.v3.endpoint.Endpoint> instance.
  - ignore_missing — When set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the endpoint does not exist. When set to True, no exception will be set when attempting to delete a nonexistent endpoint.
- Returns: None
find_endpoint(name_or_id, ignore_missing=True) — Find a single endpoint 🎀
- Parameters:
  - name_or_id — The name or ID of a endpoint.
  - ignore_missing — When set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the resource does not exist. When set to True, None will be returned when attempting to find a nonexistent resource.
- Returns: One Endpoint <#openstack.identity.v3.endpoint.Endpoint> or None
get_endpoint(endpoint) — Get a single endpoint 🦋
- Parameters:
  - endpoint — The value can be the ID of an endpoint or a Endpoint <#openstack.identity.v3.endpoint.Endpoint> instance.
- Returns: One Endpoint <#openstack.identity.v3.endpoint.Endpoint>
- Raises: NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found.
endpoints(**query) — Retrieve a generator of endpoints 🌈
- Parameters:
  - query — Optional query parameters to be sent to limit the resources being returned.
- Returns: A generator of endpoint instances.
update_endpoint(endpoint, **attrs) — Update a endpoint 💖
- Parameters:
  - endpoint — Either the ID of an endpoint or a Endpoint <#openstack.identity.v3.endpoint.Endpoint> instance.
  - attrs — The attributes to update on the endpoint represented by endpoint.
- Returns: The updated endpoint
endpoint_group_endpoints(endpoint_group, **query) — Retrieve a generator of endpoints which are associated with the endpoint_group. 👑
- Parameters:
  - endpoint_group — Either the endpoint_group ID or an instance of EndpointGroup
  - query — Optional query parameters to be sent to limit the resources being returned.
- Returns: A generator of endpoint instances.
project_endpoints(project, **query) — Retrieve a generator of endpoints which are associated with the project. 🌸
- Parameters:
  - project — Either the project ID or an instance of Project <#openstack.identity.v3.project.Project>
  - query — Optional query parameters to be sent to limit the resources being returned.
- Returns: A generator of endpoint instances.
associate_endpoint_with_project(project, endpoint) — Creates a direct association between project and endpoint 🔥
- Parameters:
  - project — Either the ID of a project or a Project <#openstack.identity.v3.project.Project> instance.
  - endpoint — Either the ID of an endpoint or a Endpoint <#openstack.identity.v3.endpoint.Endpoint> instance.
- Returns: None
disassociate_endpoint_from_project(project, endpoint) — Removes a direct association between project and endpoint 💀
- Parameters:
  - project — Either the ID of a project or a Project <#openstack.identity.v3.project.Project> instance.
  - endpoint — Either the ID of an endpoint or a Endpoint <#openstack.identity.v3.endpoint.Endpoint> instance.
- Returns: None

💖 Endpoint Group Operations 💖

Same proxy class signature, exact same kwargs — here it is in all its glory:

       class openstack.identity.v3._proxy.Proxy(session, *, service_type=None,
       service_name=None, interface=None, region_name=None,
       endpoint_override=None, version=None, auth=None, user_agent=None,
       connect_retries=None, logger=None, allow=None, additional_headers=None,
       client_name=None, client_version=None, allow_version_hack=None,
       global_request_id=None, min_version=None, max_version=None,
       default_microversion=None, status_code_retries=None,
       retriable_status_codes=None, raise_exc=None, rate_limit=None,
       concurrency=None, connect_retry_delay=None,
       status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
       prometheus_counter=None, prometheus_histogram=None,
       influxdb_config=None, influxdb_client=None)

create_endpoint_group(**attrs) — Create a new endpoint group from attributes 🎀
- Parameters:
  - attrs — Keyword arguments which will be used to create a EndpointGroup, comprised of the properties on the EndpointGroup class.
- Returns: The results of endpoint group creation
delete_endpoint_group(endpoint_group, ignore_missing=True) — Delete an endpoint group 💅
- Parameters:
  - endpoint_group — The value can be either the ID of an endpoint group or a EndpointGroup instance.
  - ignore_missing — When set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the endpoint group does not exist. When set to True, no exception will be set when attempting to delete a nonexistent endpoint group.
- Returns: None
find_endpoint_group(name_or_id, ignore_missing=True) — Find a single endpoint group 🦋
- Parameters:
  - name_or_id — The name or ID of a endpoint group.
  - ignore_missing — When set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the resource does not exist. When set to True, None will be returned when attempting to find a nonexistent resource.
- Returns: One EndpointGroup or None
get_endpoint_group(endpoint_group) — Get a single endpoint group 🌈
- Parameters:
  - endpoint_group — The value can be the ID of an endpoint group or a EndpointGroup instance.
- Returns: One EndpointGroup
- Raises: NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found.
endpoint_groups(**query) — Retrieve a generator of endpoint groups ✨
- Parameters:
  - query — Optional query parameters to be sent to limit the resources being returned.
- Returns: A generator of endpoint group instances.
update_endpoint_group(endpoint_group, **attrs) — Update an endpoint group 💖
- Parameters:
  - endpoint_group — Either the ID of an endpoint group or a EndpointGroup instance.
  - attrs — The attributes to update on the endpoint group represented by endpoint_group.
- Returns: The updated endpoint group
project_endpoint_groups(project, **query) — Retrieve a generator of endpoint groups which are associated with the project. 👑
- Parameters:
  - project — Either the project ID or an instance of Project <#openstack.identity.v3.project.Project>
  - query — Optional query parameters to be sent to limit the resources being returned.
- Returns: A generator of endpoint group instances.

🌸 Group Operations 🌸

Same proxy class signature again — no cap, it really is this long:

       class openstack.identity.v3._proxy.Proxy(session, *, service_type=None,
       service_name=None, interface=None, region_name=None,
       endpoint_override=None, version=None, auth=None, user_agent=None,
       connect_retries=None, logger=None, allow=None, additional_headers=None,
       client_name=None, client_version=None, allow_version_hack=None,
       global_request_id=None, min_version=None, max_version=None,
       default_microversion=None, status_code_retries=None,
       retriable_status_codes=None, raise_exc=None, rate_limit=None,
       concurrency=None, connect_retry_delay=None,
       status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
       prometheus_counter=None, prometheus_histogram=None,
       influxdb_config=None, influxdb_client=None)

create_group(**attrs) — Create a new group from attributes 🫶
- Parameters:
  - attrs — Keyword arguments which will be used to create a Group <#openstack.identity.v3.group.Group>, comprised of the properties on the Group class.
- Returns: The results of group creation ✨

`delete_group(group, ignore_missing=True)`

Delete a group 🗑️ — bye bestie, you're out of the group chat (the literal group chat).

group — honestly could be either the ID of a group, or a full Group <#openstack.identity.v3.group.Group> instance. Either one works, she's flexible.
ignore_missing — okay so this is the important one. Set it to False and a NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the group doesn't exist. Set it to True and no exception will be set when attempting to delete a nonexistent group. So True = "idk her, moving on 💅", False = "we're gonna have a problem".

Returns — None. That's it. Nothing. Void. Silence. 😌

`find_group(name_or_id, ignore_missing=True, **query)`

Find a single group 🔍 — one (1) group, no more, no less.

name_or_id — the name or ID of a group. That's the whole brief.
ignore_missing — set to False and NotFoundException <#openstack.exceptions.NotFoundException> gets raised when the resource doesn't exist. Set to True and None gets returned when attempting to find a nonexistent resource. So like, you asked, she's not there, you get None and you can go about your day 🫶

Returns — One Group <#openstack.identity.v3.group.Group> or None. That's the vibe check result.

`get_group(group)`

Get a single group ⭐ — just one, thanks.

group — the value can be the ID of a group or a Group <#openstack.identity.v3.group.Group> instance.

Returns — One Group <#openstack.identity.v3.group.Group>.

Raises — NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found. So if she's not there, she's not there, and the SDK will let you know loudly 😭

`groups(**query)`

Retrieve a generator of groups ✨ — all of them, streaming in like your feed.

query — optional query parameters to be sent to limit the resources being returned. Use this if you don't want the entire population of groups, bestie.

Returns — a generator of group instances. Generator, not a list, iykyk 🔥

`update_group(group, **attrs)`

Update a group 🎀 — little glow-up, no big deal.

group — either the ID of a group or a Group <#openstack.identity.v3.group.Group> instance.
attrs — the attributes to update on the group represented by group. Whatever you pass, that's what changes.

Returns — the updated group 👑

`add_user_to_group(user, group)`

Add user to group 🫶 — putting the person in the group chat.

user — either the ID of a user or a User <#openstack.identity.v3.user.User> instance.
group — either the ID of a group or a Group <#openstack.identity.v3.group.Group> instance.

Returns — None. She did the thing and said nothing. Main character energy.

`remove_user_from_group(user, group)`

Remove user to group 💀 — yes, that's how the original says it, and yes, it means taking the user out of the group. Nobody's perfect.

user — either the ID of a user or a User <#openstack.identity.v3.user.User> instance.
group — either the ID of a group or a Group <#openstack.identity.v3.group.Group> instance.

Returns — None. Boom, they're out. 🙈

`check_user_in_group(user, group)`

Check whether user belongsto group 👀 — the ultimate "are they in the group chat or not".

user — either the ID of a user or a User <#openstack.identity.v3.user.User> instance.
group — either the ID of a group or a Group <#openstack.identity.v3.group.Group> instance.

Returns — a boolean representing current relation. So True = they're in, False = they're not. Periodt.

`group_users(group, **attrs)`

List users in a group 🌈 — the full roster.

group — either the ID of a group or a Group <#openstack.identity.v3.group.Group> instance.
attrs — heads up, only password_expires_at can be filter for result. That is literally the only one, so don't try anything else 💅

Returns — List of User <#openstack.identity.v3.user.User>. The whole squad, listed out.

🦋 Policy Operations 🦋

class openstack.identity.v3._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

Yes bestie, that whole signature is real and every single kwarg is there. Do not ask me to shorten it, I would never 😤

`create_policy(**attrs)`

Create a new policy from attributes ✨ — birthing a policy, iconic.

attrs — keyword arguments which will be used to create a Policy <#openstack.identity.v3.policy.Policy>, comprised of the properties on the Policy class.

Returns — the results of policy creation. Look at her, she's created 💖

`delete_policy(policy, ignore_missing=True)`

Delete a policy 🗑️ — say bye.

policy — the value can be either the ID of a policy or a Policy <#openstack.identity.v3.policy.Policy> instance.
ignore_missing — set to False and NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the policy does not exist. Set to True and no exception will be set when attempting to delete a nonexistent policy. Ghost policy? No problem. 🫶

Returns — None. Nothing to report.

`find_policy(name_or_id, ignore_missing=True)`

Find a single policy 🔍 — just the one, thank you.

name_or_id — the name or ID of a policy.
ignore_missing — set to False and NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the resource does not exist. Set to True and None will be returned when attempting to find a nonexistent resource. She's either there or she's a None, no drama.

Returns — One Policy <#openstack.identity.v3.policy.Policy> or None.

`get_policy(policy)`

Get a single policy ⭐ — grab her.

policy — the value can be the ID of a policy or a Policy <#openstack.identity.v3.policy.Policy> instance.

Returns — One Policy <#openstack.identity.v3.policy.Policy>.

Raises — NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found. Loud and clear 📢

`policies(**query)`

Retrieve a generator of policies 🎀 — all of them, one by one.

query — optional query parameters to be sent to limit the resources being returned. Filtering is self-care.

Returns — a generator of policy instances. Not a list! A generator. Ngl this matters.

`update_policy(policy, **attrs)`

Update a policy 💅 — the glow-up chapter.

policy — either the ID of a policy or a Policy <#openstack.identity.v3.policy.Policy> instance.
attrs — the attributes to update on the policy represented by policy.

Returns — the updated policy. Serving fresh ✨

🌸 Project Operations 🌸

class openstack.identity.v3._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

Same signature, same energy, different operations. She's consistent like that. 💜

`create_project(**attrs)`

Create a new project from attributes 🔥 — new project, new era.

attrs — keyword arguments which will be used to create a Project <#openstack.identity.v3.project.Project>, comprised of the properties on the Project class.

Returns — the results of project creation. Slay.

`delete_project(project, ignore_missing=True)`

Delete a project 💀 — close the whole thing down.

project — the value can be either the ID of a project or a Project <#openstack.identity.v3.project.Project> instance.
ignore_missing — set to False and NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the project does not exist. Set to True and no exception will be set when attempting to delete a nonexistent project. So if you're not sure she's real, leave it at True and move on with your life 😌

Returns — None.

`find_project(name_or_id, ignore_missing=True, **query)`

Find a single project 🦋 — one project, coming right up.

name_or_id — the name or ID of a project.
ignore_missing — bestie, if you set this to False, a NotFoundException <#openstack.exceptions.NotFoundException> gets thrown the moment the resource doesn't exist, no cap. Set it to True instead and you just get None back when you go looking for something that's not there. Softest possible landing tbh 🫶

Returns

One Project <#openstack.identity.v3.project.Project> or None — that's it, that's the whole vibe ✨

💖 `get_project(project)`

Grab exactly one project. One. Singular. Main character only 🌟

Parameters

project — this can be the ID of a project, or a whole Project <#openstack.identity.v3.project.Project> instance if you already have one chilling in your code.

Returns

One Project <#openstack.identity.v3.project.Project> 💅

Heads up: this Raises NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found. So if there's nothing there, it WILL tell you, loudly 😭

🌸 `projects(**query)`

Retrieve a generator of projects — like, all of them, streaming at you one at a time, no big list energy 🦋

Parameters

query — optional query parameters you can send along to limit the resources being returned. Filter away, queen 👑

Returns

A generator of project instances. It's giving infinite scroll but for projects fr fr.

🎀 `user_projects(user, **query)`

Retrieve a generator of projects to which the user has authorization to access. Basically "what can this person even touch" check 🔥

Parameters

user — either the user id or an instance of User <#openstack.identity.v3.user.User>
query — optional query parameters to be sent to limit the resources being returned.

Returns

A generator of project instances 🌈

⭐ `endpoint_projects(endpoint, **query)`

Retrieve a generator of projects which are associated with the endpoint. The linkage detective work, lowkey iconic 🕵️‍♀️

Parameters

endpoint — either the endpoint ID or an instance of Endpoint <#openstack.identity.v3.endpoint.Endpoint>
query — optional query parameters to be sent to limit the resources being returned.

Returns

A generator of project instances 💜

🦋 `update_project(project, **attrs)`

Update a project. Glow-up time ✨

Parameters

project — either the ID of a project or a Project <#openstack.identity.v3.project.Project> instance.
attrs — the attributes to update on the project represented by project.

Returns

The updated project 👑

💀 `endpoint_group_projects(endpoint_group, **query)`

Retrieve a generator of projects which are associated with the endpoint group. Group-chat membership but for projects, iykyk 🫶

Parameters

group (endpoint) — either the endpoint group ID or an instance of EndpointGroup
query — optional query parameters to be sent to limit the resources being returned.

Returns

A generator of project instances 🌟

🍓 `associate_project_with_endpoint_group(endpoint_group, project)`

Create a direct association between the endpoint group and project. Matchmaker, matchmaker 🧚

Parameters

endpoint_group — either the ID of an endpoint group or a EndpointGroup instance.
project — either the ID of a project or a Project <#openstack.identity.v3.project.Project> instance.

Returns

None — nothing back, but the connection is made, trust 💖

🙈 `disassociate_project_from_endpoint_group(endpoint_group, project)`

Removes a direct association between endpoint group and project. Unmatching, we've all been there 😭

Parameters

endpoint_group — either the ID of an endpoint group or a EndpointGroup instance.
project — either the ID of a project or a Project <#openstack.identity.v3.project.Project> instance.

Returns

None 🫥

✨ Service Operations ✨

Okay so here's the class you're working through. Copy it exactly, don't be creative with it bestie:

class openstack.identity.v3._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

💅 `create_service(**attrs)`

Create a new service from attributes. New service just dropped 🔥

Parameters

attrs — keyword arguments which will be used to create a Service <#openstack.identity.v3.service.Service>, comprised of the properties on the Service class.

Returns

The results of service creation ✨

🧚 `delete_service(service, ignore_missing=True)`

Delete a service. Bye bestie 👋

Parameters

service — the value can be either the ID of a service or a Service <#openstack.identity.v3.service.Service> instance.
ignore_missing — when set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the service does not exist. When set to True, no exception will be set when attempting to delete a nonexistent service. Chill mode is the default 🫶

Returns

None

🌈 `find_service(name_or_id, ignore_missing=True)`

Find a single service. Detective mode, activated 🕵️‍♀️

Parameters

name_or_id — the name or ID of a service.
ignore_missing — when set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the resource does not exist. When set to True, None will be returned when attempting to find a nonexistent resource.

Returns

One Service <#openstack.identity.v3.service.Service> or None — could go either way, honestly 💀

🎀 `get_service(service)`

Get a single service. Just the one. Very demure 🌸

Parameters

service — the value can be the ID of a service or a Service <#openstack.identity.v3.service.Service> instance.

Returns

One Service <#openstack.identity.v3.service.Service> ⭐

Raises NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found. So like, don't be surprised 😭

🦋 `services(**query)`

Retrieve a generator of services — streaming the whole lineup at you 💜

Parameters

query — optional query parameters to be sent to limit the resources being returned.

Returns

A generator of service instances. Periodt.

👑 `update_service(service, **attrs)`

Update a service. Service glow-up arc 🌟

Parameters

service — either the ID of a service or a Service <#openstack.identity.v3.service.Service> instance.
attrs — the attributes to update on the service represented by service.

Returns

The updated service 🔥

💜 User Operations 💜

Same class, same exact signature — yes, it's the same block again, that's just how the page is laid out, don't come for me 🙈

class openstack.identity.v3._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

🍓 `create_user(**attrs)`

Create a new user from attributes. New person, who dis 💅

Parameters

attrs — keyword arguments which will be used to create a User <#openstack.identity.v3.user.User>, comprised of the properties on the User class.

Returns

The results of user creation ✨

🌸 `delete_user(user, ignore_missing=True)`

Delete a user. It's giving blocked 🫥

Parameters

user — the value can be either the ID of a user or a User <#openstack.identity.v3.user.User> instance.
ignore_missing — when set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the user does not exist. When set to True, no exception will be set when attempting to delete a nonexistent user.

Returns

None 🎀

⭐ `find_user(name_or_id, ignore_missing=True, **query)`

Find a single user. Where they at 👀

Parameters

name_or_id — the name or ID of a user.
ignore_missing — vibe check on missing stuff: set it to False and a NotFoundException <#openstack.exceptions.NotFoundException> gets thrown the moment the resource doesn't exist. Set it to True and you just get None back when you go looking for something that isn't there. no drama, no crash. 🫶

Returns One User <#openstack.identity.v3.user.User> or None

`get_user(user)`

Get a single user. one. just the one. 💅

Parameters

user — can be the ID of a user, or a User <#openstack.identity.v3.user.User> instance. either is slay.

Returns One User <#openstack.identity.v3.user.User>

Raises NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found. so like, if it's giving nothing, it tells you. 😭

`user_groups(user)`

List groups a user is in. like, which group chats is this person actually in. 👑

Parameters

user — either the ID of a user or a User <#openstack.identity.v3.user.User> instance

Returns List of group

`users(**query)`

Retrieve a generator of users. all of them. a whole generator, so it's lowkey efficient bestie. ✨

Parameters

query — Optional query parameters to be sent to limit the resources being returned.

Returns A generator of user instances.

`update_user(user, **attrs)`

Update a user. glow-up time. 🦋

Parameters

user — Either the ID of a user or a User <#openstack.identity.v3.user.User> instance.
attrs — The attributes to update on the user represented by attrs.

Returns The updated user

`update_password(user, current_password, password)`

Update the password for the user the token belongs to. putting in the old one to set the new one, very "confirm your identity" of it. 🔐

Parameters

user — Either the ID of a user or a User <#openstack.identity.v3.user.User> instance.
current_password — The user's current password.
password — The user's new password.

Returns None

🎀 Token Operations 🎀

class openstack.identity.v3._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

`validate_token(token, nocatalog=False, allow_expired=False)`

Validate a token. is it real? is it valid? we find out. 🔥

Parameters

token — The token to validate.
nocatalog — Whether the returned token should not include a catalog.
allow_expired — Whether to allow expired tokens.

Returns A Token <#openstack.identity.v3.token.Token>.

`check_token(token, allow_expired=False)`

Check if a token is valid. simple yes-or-no energy. ⭐

Parameters

token — The token to check.
allow_expired — Whether to allow expired tokens.

Returns True if valid, else False.

`revoke_token(token)`

Revoke a token. blocking them. unfollowing. it's over. 💀

Parameters

token — The token to revoke.

Returns None

💖 Trust Operations 💖

class openstack.identity.v3._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

`create_trust(**attrs)`

Create a new trust from attributes. building trust fr fr. 🫶

Parameters

attrs — Keyword arguments which will be used to create a Trust <#openstack.identity.v3.trust.Trust>, comprised of the properties on the Trust class.

Returns The results of trust creation

`delete_trust(trust, ignore_missing=True)`

Delete a trust. okay bye. 👋

Parameters

trust — The value can be either the ID of a trust or a Trust <#openstack.identity.v3.trust.Trust> instance.
ignore_missing — When set to False NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the credential does not exist. When set to True, no exception will be set when attempting to delete a nonexistent credential.

Returns None

`find_trust(name_or_id, ignore_missing=True)`

Find a single trust. where is it. we must locate it. 🔍

Parameters

name_or_id — The name or ID of a trust.
ignore_missing — When set to False NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the resource does not exist. When set to True, None will be returned when attempting to find a nonexistent resource.

Returns One Trust <#openstack.identity.v3.trust.Trust> or None

`get_trust(trust)`

Get a single trust. just the one. giving main character. 👑

Parameters

trust — The value can be the ID of a trust or a Trust <#openstack.identity.v3.trust.Trust> instance.

Returns One Trust <#openstack.identity.v3.trust.Trust>

Raises NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found.

`trusts(**query)`

Retrieve a generator of trusts. the whole collection, lazily. ✨

Parameters

query — Optional query parameters to be sent to limit the resources being returned.

Returns A generator of trust instances.

🌈 Region Operations 🌈

class openstack.identity.v3._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

`create_region(**attrs)`

Create a new region from attributes. new region just dropped. 🌍

Parameters

attrs — Keyword arguments which will be used to create a Region <#openstack.identity.v3.region.Region>, comprised of the properties on the Region class.

Returns The results of region creation.

`delete_region(region, ignore_missing=True)`

Delete a region. yeeting it. 🗑️

Parameters

region — The value can be either the ID of a region or a Region <#openstack.identity.v3.region.Region> instance.
ignore_missing — When set to False NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the region does not exist. When set to True, no exception will be thrown when attempting to delete a nonexistent region.

Returns None

`find_region(name_or_id, ignore_missing=True)`

Find a single region. gotta find it first bestie. 🔎

Parameters

name_or_id — The name or ID of a region.
ignore_missing — When set to False NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the region does not exist. When set to True, None will be returned when attempting to find a nonexistent region.

Returns One Region <#openstack.identity.v3.region.Region> or None

`get_region(region)`

Get a single region. 💅

Parameters

region — The value can be the ID of a region or a Region <#openstack.identity.v3.region.Region> instance.

Returns One Region <#openstack.identity.v3.region.Region>

Raises NotFoundException <#openstack.exceptions.NotFoundException> when no matching region can be found.

`regions(**query)`

Retrieve a generator of regions

Parameters

query — optional query params bestie, sent along to limit the regions being returned. 💅

Returns

A generator of region instances. ✨

✨ `update_region(region, **attrs)` ✨

Update a region. We love a lil glow-up. 💖

Parameters

region — either the ID of a region or a Region instance (openstack.identity.v3.region.Region). 🦋
attrs — the attributes to update on the region represented by region. 🎀

Returns

The updated region. Slay. 👑

💖 Role Operations 💖

class openstack.identity.v3._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

🌸 `create_role(**attrs)` 🌸

Create a shiny new role from attributes. Main character creation energy. 💫

Parameters

attrs — keyword arguments used to create a Role (openstack.identity.v3.role.Role), made up of the properties on the Role class. 🎀

Returns

The results of role creation. Obsessed. 💖

🦋 `delete_role(role, ignore_missing=True)` 🦋

Delete a role. Bye bestie. 👋

Parameters

role — the value can be either the ID of a role or a Role instance (openstack.identity.v3.role.Role). 💅
ignore_missing — when set to False, NotFoundException (openstack.exceptions.NotFoundException) will be raised when the role does not exist. When set to True, no exception will be thrown when attempting to delete a nonexistent role. 🙈

Returns

None — that's literally it. 🤷‍♀️

🎀 `find_role(name_or_id, ignore_missing=True, **query)` 🎀

Find a single role. Detective mode: activated. 🔍

Parameters

name_or_id — the name or ID of a role. 🦋
ignore_missing — when set to False, NotFoundException (openstack.exceptions.NotFoundException) will be raised when the role does not exist. When set to True, None will be returned when attempting to find a nonexistent role. 😭

Returns

One Role (openstack.identity.v3.role.Role) or None. 💅

✨ `get_role(role)` ✨

Get a single role. Gimme gimme. 🫶

Parameters

role — the value can be the ID of a role or a Role instance (openstack.identity.v3.role.Role). 🌸

Returns

One Role (openstack.identity.v3.role.Role). 👑

Raises

NotFoundException (openstack.exceptions.NotFoundException) when no matching role can be found. 💀

🌈 `roles(**query)` 🌈

Retrieve a generator of roles. Endless scroll, but make it IAM. 📜

Parameters

query — optional query parameters to be sent to limit the resources being returned. The options are: domain_id, name. ✨

Returns

A generator of role instances. 🦋

💜 `update_role(role, **attrs)` 💜

Update a role. Small tweaks, big vibes. 💅

Parameters

role — either the ID of a role or a Role instance (openstack.identity.v3.role.Role). 🎀
kwargs — the attributes to update on the role represented by value. Only name can be updated. ⚠️

Returns

The updated role. Slay. 👑

🎀 Role Assignment Operations 🎀

class openstack.identity.v3._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

🦋 `role_assignments_filter(domain=None, project=None, system=None, group=None, user=None)` 🦋

Retrieve a generator of roles assigned to user/group. Filtering era. 💖

Parameters

domain — either the ID of a domain or a Domain instance (openstack.identity.v3.domain.Domain). 🌸
project — either the ID of a project or a Project instance (openstack.identity.v3.project.Project). 🎀
system — either the system name or a System instance (openstack.identity.v3.system.System). 🦋
group — either the ID of a group or a Group instance (openstack.identity.v3.group.Group). 💅
user — either the ID of a user or a User instance (openstack.identity.v3.user.User). ✨

Returns

A generator of role instances. 🌈

💜 `role_assignments(**query)` 💜

Retrieve a generator of role assignments. The lore. 📚

Parameters

query — optional query parameters to be sent to limit the resources being returned. The options are: group_id, role_id, scope_domain_id, scope_project_id, inherited_to, user_id, include_names, include_subtree. 🎀

Returns

RoleAssignment (openstack.identity.v3.role_assignment.RoleAssignment). 👑

🌸 `assign_domain_role_to_user(domain, user, role, *, inherited=False)` 🌸

Assign role to user on a domain. Giving them the keys, respectfully. 🔑

Parameters

domain — either the ID of a domain or a Domain instance (openstack.identity.v3.domain.Domain). 🦋
user — either the ID of a user or a User instance (openstack.identity.v3.user.User). 💅
role — either the ID of a role or a Role instance (openstack.identity.v3.role.Role). 🎀
inherited — whether the role assignment is inherited. 🌱

Returns

None — no cap. ✨

🦋 `unassign_domain_role_from_user(domain, user, role, *, inherited=False)` 🦋

Unassign role from user on a domain. Revoking access, iconic behavior. 🚫

Parameters

domain — either the ID of a domain or a Domain instance (openstack.identity.v3.domain.Domain). 🌸
user — either the ID of a user or a User instance (openstack.identity.v3.user.User). 💅
role — either the ID of a role or a Role instance (openstack.identity.v3.role.Role). 🎀
inherited — whether the role assignment is inherited. 🌱

Returns

None. Periodt. 💅

✨ `validate_user_has_domain_role(domain, user, role, *, inherited=False)` ✨

Validates that a user has a role on a domain. Vibe check, but for IAM. ✅

Parameters

domain — either the ID of a domain or a Domain instance (openstack.identity.v3.domain.Domain). 🦋
user — either the ID of a user or a User instance (openstack.identity.v3.user.User). 💅
role — either the ID of a role or a Role instance (openstack.identity.v3.role.Role). 🎀

Returns

True if user has role in domain. 🔥

🎀 `assign_domain_role_to_group(domain, group, role, *, inherited=False)` 🎀

Assign role to group on a domain. Group chat gets permissions. 💬

Parameters

domain — either the ID of a domain or a Domain instance (openstack.identity.v3.domain.Domain). 🌸
group — either the ID of a group or a Group instance (openstack.identity.v3.group.Group). 🦋
role — either the ID of a role or a Role instance (openstack.identity.v3.role.Role). 💅
inherited — whether the role assignment is inherited. 🌱

Returns

None. 💖

🌈 `unassign_domain_role_from_group(domain, group, role, *, inherited=False)` 🌈

Unassign role from group on a domain. Removing them from the group project. 😭

Parameters

domain — either the ID of a domain or a Domain instance (openstack.identity.v3.domain.Domain). 🎀
group — either the ID of a group or a Group instance (openstack.identity.v3.group.Group). 🦋
role — either the ID of a role or a Role instance (openstack.identity.v3.role.Role). 💅
inherited — whether the role assignment is inherited. 🌱

Returns

None. 🫶

💜 `validate_group_has_domain_role(domain, group, role, *, inherited=False)` 💜

Validates that a group has a role on a domain. Checking the receipts. 🧾

Parameters

domain — either the ID of a domain, or a Domain instance (that's openstack.identity.v3.domain.Domain for you ✨)
- group — either the ID of a group, or a Group instance (openstack.identity.v3.group.Group)
- role — either the ID of a role, or a Role instance (openstack.identity.v3.role.Role)

Returns — True if the group has that role on the domain 🫶

`assign_project_role_to_user(project, user, role, *, inherited=False)`

Hand a role to a user, on a project. That's it, that's the vibe 💅

Parameters

project — either the ID of a project, or a Project instance (openstack.identity.v3.project.Project)
user — either the ID of a user, or a User instance (openstack.identity.v3.user.User)
role — either the ID of a role, or a Role instance (openstack.identity.v3.role.Role)
inherited — whether the role assignment is inherited 👑

Returns — None

`unassign_project_role_from_user(project, user, role, *, inherited=False)`

Take that role back from the user on a project. Reversal arc, we love to see it 😭

Parameters

project — either the ID of a project, or a Project instance (openstack.identity.v3.project.Project)
user — either the ID of a user, or a User instance (openstack.identity.v3.user.User)
role — either the ID of a role, or a Role instance (openstack.identity.v3.role.Role)
inherited — whether the role assignment is inherited 👑

Returns — None

`validate_user_has_project_role(project, user, role, *, inherited=False)`

Checks that a user fr fr has a role on a project 🔍

Parameters

project — either the ID of a project, or a Project instance (openstack.identity.v3.project.Project)
user — either the ID of a user, or a User instance (openstack.identity.v3.user.User)
role — either the ID of a role, or a Role instance (openstack.identity.v3.role.Role)

Returns — True if the user has that role in the project 💖

`assign_project_role_to_group(project, group, role, *, inherited=False)`

Same energy as the user version, but the whole group eats 🍓

Parameters

project — either the ID of a project, or a Project instance (openstack.identity.v3.project.Project)
group — either the ID of a group, or a Group instance (openstack.identity.v3.group.Group)
role — either the ID of a role, or a Role instance (openstack.identity.v3.role.Role)
inherited — whether the role assignment is inherited 👑

Returns — None

`unassign_project_role_from_group(project, group, role, *, inherited=False)`

Yank the role back off the group on that project 🙈

Parameters

project — either the ID of a project, or a Project instance (openstack.identity.v3.project.Project)
group — either the ID of a group, or a Group instance (openstack.identity.v3.group.Group)
role — either the ID of a role, or a Role instance (openstack.identity.v3.role.Role)
inherited — whether the role assignment is inherited 👑

Returns — None

`validate_group_has_project_role(project, group, role, *, inherited=False)`

Vibe check: does this group actually have this role on this project? 🌈

Parameters

project — either the ID of a project, or a Project instance (openstack.identity.v3.project.Project)
group — either the ID of a group, or a Group instance (openstack.identity.v3.group.Group)
role — either the ID of a role, or a Role instance (openstack.identity.v3.role.Role)

Returns — True if the group has that role in the project ✨

`assign_system_role_to_user(user, role, system)`

Now we're at the system level — assign a role to a user on a system, no inherited kwarg here bestie, note the difference 💀

Parameters

user — either the ID of a user, or a User instance (openstack.identity.v3.user.User)
role — either the ID of a role, or a Role instance (openstack.identity.v3.role.Role)
system — the system name

Returns — None

`unassign_system_role_from_user(user, role, system)`

Take the system-level role away from the user. Bye bestie 👋

Parameters

user — either the ID of a user, or a User instance (openstack.identity.v3.user.User)
role — either the ID of a role, or a Role instance (openstack.identity.v3.role.Role)
system — the system name

Returns — None

`validate_user_has_system_role(user, role, system)`

Does the user hold this role on the system? Let's find out 🔥

Parameters

user — either the ID of a user, or a User instance (openstack.identity.v3.user.User)
role — either the ID of a role, or a Role instance (openstack.identity.v3.role.Role)
system — the system name

Returns — True if the user has that role in the system 💜

`assign_system_role_to_group(group, role, system)`

Group edition of the system-level handout. Same three args, no kwarg 🎀

Parameters

group — either the ID of a group, or a Group instance (openstack.identity.v3.group.Group)
role — either the ID of a role, or a Role instance (openstack.identity.v3.role.Role)
system — the system name

Returns — None

`unassign_system_role_from_group(group, role, system)`

And the un-assign for the group on the system. Clean up your messes, icon 💅

Parameters

group — either the ID of a group, or a Group instance (openstack.identity.v3.group.Group)
role — either the ID of a role, or a Role instance (openstack.identity.v3.role.Role)
system — the system name

Returns — None

`validate_group_has_system_role(group, role, system)`

Checks whether the group has the role on the system. The final vibe check of this little saga 🦋

Parameters

group — either the ID of a group, or a Group instance (openstack.identity.v3.group.Group)
role — either the ID of a role, or a Role instance (openstack.identity.v3.role.Role)
system — the system name

Returns — True if the group has that role on the system ⭐

🎀 Registered Limit Operations 🎀

New section, new obsession. Meet the proxy class in all its glory — yes we're printing the whole signature, it's giving main character 🧚

class openstack.identity.v3._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

`registered_limits(**query)`

Gives you a generator of registered_limits — yes, a generator, so it's lazy and cute about it ✨

Parameters

query — optional query parameters, sent along to limit which registered_limits come back to you.

Returns — a generator of registered_limits instances. That's RegisteredLimit (openstack.identity.v3.registered_limit.RegisteredLimit) 🫶

`get_registered_limit(registered_limit)`

Grabs one single registered_limit. Just the one. Lowkey the simplest method here 💖

Parameters

registered_limit — the value can be the ID of a registered_limit, or a RegisteredLimit instance (openstack.identity.v3.registered_limit.RegisteredLimit).

Returns — one RegisteredLimit (openstack.identity.v3.registered_limit.RegisteredLimit).

Raises — NotFoundException (openstack.exceptions.NotFoundException) when no resource can be found 😭

`create_registered_limit(**attrs)`

Builds a brand-new registered_limit out of attributes you pass in 🌸

Parameters

attrs — keyword arguments which will be used to create a RegisteredLimit (openstack.identity.v3.registered_limit.RegisteredLimit), comprised of the properties on the RegisteredLimit class.

Returns — the results of registered_limit creation.

`update_registered_limit(registered_limit, **attrs)`

Updates an existing registered_limit, because glow-ups are real 👑

Parameters

aaaand the parameter list is where this part cuts off — next part picks it right back up, don't @ me 💀

registered_limit — either the ID of a registered_limit, or a RegisteredLimit instance (openstack.identity.v3.registered_limit.RegisteredLimit for the full flex 💅).
kwargs — the attributes you want to update on the registered_limit that value points at.

Returns — the updated registered_limit. slay ✨

🎀 `delete_registered_limit(registered_limit, ignore_missing=True)`

Deletes a registered_limit. bye bestie 👋

Parameters

registered_limit — either the ID of a registered_limit, or a RegisteredLimit instance (openstack.identity.v3.registered_limit.RegisteredLimit).
ignore_missing — set it to False and NotFoundException (openstack.exceptions.NotFoundException) will be raised when the registered_limit doesn't exist. Set it to True and nothing gets thrown when you try to delete a registered_limit that was never there. no drama, no exception 🫶

Returns — None

🍋 Limit Operations

class openstack.identity.v3._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

🧵 `limits(**query)`

Gives you a generator of limits. it's giving infinite scroll but make it quotas 💀

Parameters

query — optional query parameters, sent along to limit which limits get returned. yes we said limit twice, it's that kind of day.

Returns — a generator of limits instances. 🌈

🔍 `get_limit(limit)`

Grabs one single limit. just the one. main character only 👑

Parameters

limit — the value can be the ID of a limit, or a Limit instance (openstack.identity.v3.limit.Limit).

Returns — one Limit (openstack.identity.v3.limit.Limit).

Raises NotFoundException (openstack.exceptions.NotFoundException) when no resource can be found. 😭

🛠️ `create_limit(**attrs)`

Makes a whole new limit out of attributes. build-a-bear but for identity quotas 🧸

Parameters

attrs — keyword arguments that get used to create a Limit (openstack.identity.v3.limit.Limit), made up of the properties on the Limit class.

Returns — the results of limit creation. new limit just dropped 🔥

✏️ `update_limit(limit, **attrs)`

Updates a limit. glow-up time 💅

Parameters

limit — either the ID of a limit. or a Limit instance (openstack.identity.v3.limit.Limit).
kwargs — the attributes to update on the limit represented by value.

Returns — the updated limit.

🗑️ `delete_limit(limit, ignore_missing=True)`

Deletes a limit. it's over bestie 💀

Parameters

limit — the value can be either the ID of a limit, or a Limit instance (openstack.identity.v3.limit.Limit).
ignore_missing — when set to False, NotFoundException (openstack.exceptions.NotFoundException) will be raised when the limit does not exist. When set to True, no exception will be thrown when attempting to delete a nonexistent limit. lowkey the most forgiving flag ever 🫶

Returns — None

🦋 Application Credential Operations

class openstack.identity.v3._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

🎟️ `application_credentials(user, **query)`

Hands you a generator of application credentials. no passwords, just vibes ✨

Parameters

user — either the ID of a user, or a User instance (openstack.identity.v3.user.User).
query — optional query parameters that get sent to limit the resources being returned.

Returns — a generator of application credentials instances, i.e. ApplicationCredential (openstack.identity.v3.application_credential.ApplicationCredential).

🔎 `get_application_credential(user, application_credential)`

Gets one single application credential. one (1) credential. iconic 🎀

Parameters

user — either the ID of a user, or a User instance (openstack.identity.v3.user.User).
application_credential — the value can be the ID of a application credential, or an ApplicationCredential instance (openstack.identity.v3.application_credential.ApplicationCredential).

Returns — one ApplicationCredential (openstack.identity.v3.application_credential.ApplicationCredential).

Raises NotFoundException (openstack.exceptions.NotFoundException) when no resource can be found.

🪄 `create_application_credential(user, name, **attrs)`

Creates a brand new application credential from attributes. fresh credential, who dis 🌸

Parameters

user — either the ID of a user, or a User instance (openstack.identity.v3.user.User).
name — the name of the application credential, which is unique to the user.
attrs — keyword arguments which will be used to create an ApplicationCredential (openstack.identity.v3.application_credential.ApplicationCredential), comprised of the properties on the ApplicationCredential class.

Returns — the results of application credential creation.

🕵️ `find_application_credential(user, name_or_id, ignore_missing=True, **query)`

Finds one single application credential. detective mode 🔍

Parameters

user — either the ID of a user, or a User instance (openstack.identity.v3.user.User).
name_or_id — the name or ID of an application credential.
ignore_missing — when set to False, NotFoundException (openstack.exceptions.NotFoundException) will be raised when the resource does not exist. When set to True, None will be returned when attempting to find a nonexistent resource. soft launch of a search, honestly 🫶

Returns — one ApplicationCredential (openstack.identity.v3.application_credential.ApplicationCredential) or None

🧹 `delete_application_credential(user, application_credential, ignore_missing=True)`

Deletes an application credential. revoke, block, delete 💅

Parameters

user — either the ID of a user, or a User instance (openstack.identity.v3.user.User).
application_credential — the value can be either the ID of an application credential, or an ApplicationCredential instance (openstack.identity.v3.application_credential.ApplicationCredential).
ignore_missing — when set to False, NotFoundException (openstack.exceptions.NotFoundException) will be raised when the application credential does not exist. When set to True, no exception will be thrown when attempting to delete a nonexistent application credential.

Returns — None

🧚 Federation Protocol Operations

class openstack.identity.v3._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

🌐 `create_federation_protocol(idp, **attrs)`

Creates a new federation protocol from attributes. crossing identity providers like it's nothing 💫

Parameters

delete_federation_protocol(idp, protocol, ignore_missing=True) — bestie, this deletes a federation protocol. gone. poof. 💅

Parameters:

idp — the ID, or an IdentityProvider instance (that's openstack.identity.v3.identity_provider.IdentityProvider), of the identity provider that the protocol is attached to. Pro tip from the docs: this can be None if protocol is itself a FederationProtocol (openstack.identity.v3.federation_protocol.FederationProtocol) instance. 🫶
protocol — the ID of a federation protocol, or a FederationProtocol (openstack.identity.v3.federation_protocol.FederationProtocol) instance.
ignore_missing — set it to False and a NotFoundException (openstack.exceptions.NotFoundException) gets raised when the federation protocol doesn't exist. set it to True and no exception fires when you try to delete a nonexistent federation protocol. no drama, no error, just vibes. ✨

Returns: None

find_federation_protocol(idp, protocol, ignore_missing=True) — finds you a single federation protocol, like the world's most helpful search bar 🔍

Parameters:

idp — the ID, or an IdentityProvider (openstack.identity.v3.identity_provider.IdentityProvider) instance, of the identity provider the protocol is attached to.
protocol — the name or ID of a federation protocol.
ignore_missing — False means a NotFoundException (openstack.exceptions.NotFoundException) gets raised when the resource doesn't exist. True means you just get None back when you go looking for a nonexistent resource. it's giving "no thoughts, just None" 😌

Returns: one federation protocol, or None

get_federation_protocol(idp, protocol) — grabs a single federation protocol, no searching around

Parameters:

idp — the ID, or an IdentityProvider (openstack.identity.v3.identity_provider.IdentityProvider) instance, of the identity provider the protocol is attached to. can be None if protocol is a FederationProtocol (openstack.identity.v3.federation_protocol.FederationProtocol) instance.
protocol — the value can be the ID of a federation protocol, or a FederationProtocol (openstack.identity.v3.federation_protocol.FederationProtocol) instance.

Returns: one federation protocol

Raises: NotFoundException (openstack.exceptions.NotFoundException) when no resource can be found. 💀

federation_protocols(idp, **query) — hands you a generator of federation protocols, iconic generator behaviour fr fr

Parameters:

idp — the ID, or an IdentityProvider (openstack.identity.v3.identity_provider.IdentityProvider) instance, of the identity provider the protocol is attached to.
query — optional query parameters, sent along to limit the resources being returned. use them, bestie, your list will thank you 🎀

Returns: a generator of federation protocol instances.

update_federation_protocol(idp, protocol, **attrs) — glow-up time for a federation protocol ✨

Parameters:

idp — the ID, or an IdentityProvider (openstack.identity.v3.identity_provider.IdentityProvider) instance, of the identity provider the protocol is attached to. can be None if protocol is a FederationProtocol (openstack.identity.v3.federation_protocol.FederationProtocol) instance.
protocol — either the ID of a federation protocol, or a FederationProtocol (openstack.identity.v3.federation_protocol.FederationProtocol) instance.
attrs — the attributes to update on the federation protocol represented by protocol.

Returns: the updated federation protocol

🗺️ Mapping Operations 🗺️

Same class energy, one more time — because yes, it's literally the same signature. here it is in full:

class openstack.identity.v3._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

`create_mapping(**attrs)`

Creates a brand-new mapping from attributes — mapping main character energy 👑

Parameters:

attrs — keyword arguments which will be used to create a Mapping (openstack.identity.v3.mapping.Mapping), comprised of the properties on the Mapping class.

Returns: the results of mapping creation 🌈

`delete_mapping(mapping, ignore_missing=True)`

Deletes a mapping. bye bestie 🦋

Parameters:

mapping — the ID of a mapping, or a Mapping (openstack.identity.v3.mapping.Mapping) instance.
ignore_missing — set to False and a NotFoundException (openstack.exceptions.NotFoundException) is raised when the mapping doesn't exist. set to True and no exception gets set when you attempt to delete a nonexistent mapping. we love a soft landing 💜

Returns: None

`find_mapping(name_or_id, ignore_missing=True)`

Finds a single mapping — detective mode activated 🔎

Parameters:

name_or_id — the name or ID of a mapping.
ignore_missing — False means a NotFoundException (openstack.exceptions.NotFoundException) gets raised when the resource doesn't exist. True means None comes back when you attempt to find a nonexistent resource.

Returns: one Mapping (openstack.identity.v3.mapping.Mapping), or None

`get_mapping(mapping)`

Gets a single mapping, straightforward, no cap

Parameters:

mapping — the value can be the ID of a mapping, or a Mapping (openstack.identity.v3.mapping.Mapping) instance.

Returns: one Mapping (openstack.identity.v3.mapping.Mapping)

Raises: NotFoundException (openstack.exceptions.NotFoundException) when no resource can be found. 😭

`mappings(**query)`

Retrieves a generator of mappings — yes, a generator, they're everywhere, get used to it ✨

Parameters:

query — optional query parameters to be sent to limit the resources being returned.

Returns: a generator of mapping instances.

`update_mapping(mapping, **attrs)`

Updates a mapping. little refresh, little self-care 🎀

Parameters:

mapping — either the ID of a mapping, or a Mapping (openstack.identity.v3.mapping.Mapping) instance.
attrs — the attributes to update on the mapping represented by mapping.

Returns: the updated mapping

🪪 Identity Provider Operations 🪪

And one more time, the class signature, identical, because the docs said so and we do not skip details on this page:

class openstack.identity.v3._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

`create_identity_provider(**attrs)`

Creates a new identity provider from attributes — birth of an icon 👑

Parameters:

attrs — keyword arguments which will be used to create an IdentityProvider (openstack.identity.v3.identity_provider.IdentityProvider), comprised of the properties on the IdentityProvider class.

Returns: the results of identity provider creation ⭐

delete_identity_provider(identity_provider, ignore_missing=True) — bestie, this deletes an identity provider, periodt 🗑️

Parameters:

identity_provider — the ID of an identity provider, or a IdentityProvider instance (link: <#openstack.identity.v3.identity_provider.IdentityProvider>).
ignore_missing — set this to False and a NotFoundException (link: <#openstack.exceptions.NotFoundException>) will be raised when the identity provider doesn't exist. Set it to True (the default, bestie) and literally nothing happens when you try to delete a nonexistent one. No drama. 💅

Returns: None

find_identity_provider(name_or_id, ignore_missing=True) — finds you a single identity provider, like a little scavenger hunt 🔍

Parameters:

name_or_id — the name or ID of an identity provider.
ignore_missing — set to False and NotFoundException (link: <#openstack.exceptions.NotFoundException>) gets raised when the resource doesn't exist. Set to True and you just get None back when it can't find anything.

Returns: the details of an identity provider or None.

get_identity_provider(identity_provider) — get one single mapping (yes, the docs say "mapping" here, we don't ask questions 😭)

Parameters:

mapping — the value can be the ID of an identity provider or a IdentityProvider instance (link: <#openstack.identity.v3.identity_provider.IdentityProvider>).

Returns: the details of an identity provider.

Raises NotFoundException (link: <#openstack.exceptions.NotFoundException>) when no resource can be found. 💀

identity_providers(**query) — retrieve a whole generator of identity providers, we love a generator moment ✨

Parameters:

query — optional query parameters you send to limit the resources being returned.

Returns: a generator of identity provider instances. IdentityProvider (link: <#openstack.identity.v3.identity_provider.IdentityProvider>)

update_identity_provider(identity_provider, **attrs) — update a mapping, glow-up edition 💖

Parameters:

mapping — either the ID of an identity provider or a IdentityProvider instance (link: <#openstack.identity.v3.identity_provider.IdentityProvider>).
attrs — the attributes to update on the identity_provider represented by identity_provider.

Returns: the updated identity provider.

🎀 Access Rule Operations 🎀

class openstack.identity.v3._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

access_rules(user, **query) — retrieve a generator of access rules, so many rules bestie 🦋

Parameters:

user — either the ID of a user or a User instance (link: <#openstack.identity.v3.user.User>).
query — optional query parameters to send to limit the resources being returned.

Returns: a generator of access rules instances.

delete_access_rule(user, access_rule, ignore_missing=True) — deletes an access rule, bye bye 👋

Parameters:

user — either the ID of a user or a User instance (link: <#openstack.identity.v3.user.User>).
access_rule — the value can be either the ID of an access rule or a AccessRule instance.
ignore_missing — set to False and NotFoundException (link: <#openstack.exceptions.NotFoundException>) gets raised when the access rule doesn't exist. Set to True and no exception gets thrown when you try to delete a nonexistent access rule.

Returns: None

🌈 Service Provider Operations 🌈

class openstack.identity.v3._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

create_service_provider(**attrs) — makes a brand new service provider from attributes, slay 🎉

Parameters:

attrs — keyword arguments which will be used to create a ServiceProvider, comprised of the properties on the ServiceProvider class.

Returns: the results of service provider creation.

delete_service_provider(service_provider, ignore_missing=True) — delete a service provider, no cap 🗑️

Parameters:

service_provider — the ID of a service provider or a ServiceProvider instance.
ignore_missing — set to False and NotFoundException (link: <#openstack.exceptions.NotFoundException>) will be raised when the service provider doesn't exist. Set to True and no exception gets set when attempting to delete a nonexistent service provider.

Returns: None

find_service_provider(name_or_id, ignore_missing=True) — find a single service provider, good luck bestie 🔍

Parameters:

name_or_id — the name or ID of a service provider.
ignore_missing — set to False and NotFoundException (link: <#openstack.exceptions.NotFoundException>) will be raised when the resource doesn't exist. Set to True and None gets returned when attempting to find a nonexistent resource.

Returns: the details of an service provider or None.

get_service_provider(service_provider) — get a single service provider, iconic 👑

Parameters:

service_provider — the value can be the ID of a service provider or a ServiceProvider instance.

Returns: the details of an service provider.

Raises NotFoundException (link: <#openstack.exceptions.NotFoundException>) when no resource can be found. 😭

service_providers(**query) — retrieve a generator of service providers, generators are giving main character energy ⭐

Parameters:

query — optional query parameters to be sent to limit the resources being returned.

Returns: a generator of service provider instances. ServiceProvider

update_service_provider(service_provider, **attrs) — update a service provider, glow up again 💅

Parameters:

service_provider — either the ID of an service provider or a ServiceProvider instance.
attrs — the attributes to update on the service provider represented by service_provider.

Returns: the updated service provider.

🌸 Image API v1 🌸

For details on how to use image, see Using OpenStack Image <> (the link is literally empty in the source, we're not gonna pretend otherwise 🙈).

🦋 The Image v1 Class 🦋

The image high-level interface is available through the image member of a Connection object (link: <#openstack.connection.Connection>). The image member will only be added if the service is detected. iykyk ✨

class openstack.image.v1._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

upload_image(**attrs) — upload a new image from attributes, let's gooo 🔥

Parameters:

attrs — keyword arguments which will be used to create a Image (link: <#openstack.image.v1.image.Image>), comprised of the properties on the Image class.

Returns: the results of image creation.

delete_image(image, ignore_missing=True) — delete an image, bye bestie 🗑️

Parameters:

image — this one's either the ID of an image, or a whole entire Image instance. Both slay, pick whichever feels right 🫶
ignore_missing — okay so set this to False and a NotFoundException gets raised at you the second the image doesn't exist. Set it to True and no exception will be set when you attempt to delete a nonexistent image. Choosing peace, honestly 🌸

Returns: None — that's the whole personality. Nothing. Void. 😭

find_image(name_or_id, ignore_missing=True) — finds a single image. One. Singular. Main character only 💅

Parameters

name_or_id — the name or ID of a image 🔍
ignore_missing — when it's False, a NotFoundException gets raised when the resource doesn't exist. When it's True, None gets returned when you attempt to find a nonexistent resource. No drama, no chaos ✨

Returns: one Image or None 💫

get_image(image) — gets a single image, lowkey the most straightforward one here.

Parameters

image — the ID of an image, or an Image instance.

Returns: one Image 💖

Raises: NotFoundException when no resource can be found. She's not gonna sugarcoat it for you 😭

images(**query) — returns a generator of images. Not a list, bestie, a generator. We love a lazy iterator 👑

Parameters

query — optional query parameters to be sent to limit the resources being returned. Use them or don't, the vibes are yours 🦋

Returns: a generator of image objects ⭐

update_image(image, **attrs) — updates a image.

Parameters

image — either the ID of a image, or an Image instance.
attrs — the attributes to update on the image represented by image.

Returns: the updated image 🌈

Image API v2

For details on how to use image, see Using OpenStack Image 📖

The Image v2 Class

The image high-level interface is available through the image member of a Connection object. The image member will only be added if the service is detected — so if it's just not there, that's literally why, no cap 🙈

Image Operations

class openstack.image.v2._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

Look at all those keyword args. Gorgeous. Every single one of them is a None by default and that's exactly how she likes it 🎀

create_image(name, *, filename=None, data=None, container=None,
md5=None, sha256=None, disk_format=None, container_format=None,
tags=None, disable_vendor_agent=True, allow_duplicates=False,
meta=None, wait=False, timeout=3600, validate_checksum=False,
use_import=False, import_method=None, uri=None,
remote_region=None, remote_image_id=None,
remote_service_interface=None, stores=None, all_stores=None,
all_stores_must_succeed=None, size=None, **kwargs)

Create an image and optionally upload data ✨

Creates a new image. If filename or data are provided, it will also upload data to this image.

Okay so, real talk: uploading image data is actually quite a complicated procedure. Like, genuinely. There are three ways to upload an image:

Image upload
Image import
Image tasks

If the image tasks API is enabled, this must be used. However — this API is deprecated since the Image service's Mitaka (12.0.0) release and is now admin-only. 💀 Assuming this API is not enabled, you may choose between image upload or image import. Image import is more powerful and allows you to upload data from multiple sources including other glance instances. It should be preferred on all services that support it. Periodt.

Parameters

name — name of the image to create. If it's a pathname of an image, the name will be constructed from the extensionless basename of the path. Cute, right? 🌸
filename — the path to the file to upload, if needed. (optional, defaults to None)
data — image data (string or file-like object). It is mutually exclusive with filename — pick one, not both, we've talked about this 🙈
container — name of the container in swift where images should be uploaded for import if the cloud requires such a thing. (optional, defaults to 'images')
md5 — md5 sum of the image file. If not given, an md5 will be calculated.
sha256 — sha256 sum of the image file. If not given, an md5 will be calculated. (yes bestie, it says md5 there too — that's literally what the doc says, we're just reading it out 💀)
disk_format — the disk format the image is in. (optional, defaults to the os-client-config config value for this cloud)
container_format — the container format the image is in. (optional, defaults to the os-client-config config value for this cloud)
tags — list of tags for this image. Each tag is a string of at most 255 chars. Keep 'em short and iconic 🎀
disable_vendor_agent — whether or not to append metadata flags to the image to inform the cloud in question to not expect a vendor agent to be running. (optional, defaults to True)
allow_duplicates — if true, skips checks that enforce unique image name. (optional, defaults to False)
meta — a dict of key/value pairs to use for metadata that bypasses automatic type conversion. Raw. Untouched. Feral, even 🦋
wait — if true, waits for image to be created. Defaults to true — however, be aware that one of the upload methods is always synchronous. So like, don't get too comfortable 😌
timeout — seconds to wait for image creation. None is forever. Literally forever. Think about that 🕰️
validate_checksum — if true and cloud returns checksum, compares return value with the one calculated or passed into this call. If value does not match — raises exception. Default is 'false' ⚠️
use_import — use the 'glance-direct' method of the interoperable image import mechanism to import the image. This defaults to false because it is harder on the target cloud so should only be used when needed, such as when the user needs the cloud to transform image format. If the cloud has disabled direct uploads, this will default to true. If you wish to use other import methods, use the import_image method instead 👑
import_method — method to use for importing the image. Not all deployments support all methods. One of: glance-direct (default), web-download, glance-download (copy-image is not used with create). Use of glance-direct requires the image be first staged 🔥
uri — required only if using the web-download import method. This url is where the data is made available to the Image service.
remote_region — the remote glance region to download the image from when using glance-download.
remote_image_id — the ID of the image to import from the remote glance when using glance-download.
remote_service_interface — the remote glance service interface to use when using glance-download.
stores — list of stores to be used when enabled_backends is activated in glance. List values can be the id of a store or a Store instance. Implies use_import equals True 💜
all_stores — upload to all available stores. Mutually exclusive with store and stores. Implies use_import equals True.

all_stores_must_succeed — okay so when this is True, if an error pops off during the upload in at least one store, the worfklow fails, the data is deleted from stores where copying is done (not staging), and the state of the image stays unchanged. When it’s False, the workflow will fail (data deleted from stores, …) only if the import fails on all stores specified by the user. In a partial success, the locations added to the image are the stores where the data was actually uploaded correctly. Default is True. Implies use_import equals True. 💅
size — size of the image data in bytes. Providing this lets Glance pre-allocate storage and can improve upload performance ✨. If you don’t provide it and data is a file-like object, the size will be calculated automatically.

Additional kwargs get passed to image creation as extra metadata for the image, and all values get converted to string except for min_disk, min_ram, size and virtual_size, which get converted to int.

If you are sure you have all of your data types correct or have an advanced need to be explicit, use meta. If you are just a normal consumer, using kwargs is likely the right choice. If a value is in meta and kwargs, meta wins. Periodt.

Returns: The results of image creation 🌟

Raises: SDKException if there are problems uploading 😭

🦋 `import_image`

import_image(image, method='glance-direct', *, uri=None, remote_region=None, remote_image_id=None, remote_service_interface=None, store=None, stores=None, all_stores=None, all_stores_must_succeed=None)

Import data to an existing image.

The interoperable image import process was introduced in Image API v2.6. It mainly lets image importing happen from an external URL and lets the Image service download it by itself without sending binary data at image creation. Iconic behavior, honestly 👑

Parameters

image — the value can be the ID of a image or an Image instance.
method — method to use for importing the image. Not all deployments support all methods. One of: glance-direct (default), web-download, glance-download, or copy-image. Use of glance-direct requires the image be first staged.
uri — required only if using the web-download import method. This url is where the data is made available to the Image service.
remote_region — the remote glance region to download the image from when using glance-download.
remote_image_id — the ID of the image to import from the remote glance when using glance-download.
remote_service_interface — the remote glance service interface to use when using glance-download.
store — used when enabled_backends is activated in glance. The value can be the id of a store or a Store instance.
stores — list of stores to be used when enabled_backends is activated in glance. List values can be the id of a store or a Store instance.
all_stores — upload to all available stores. Mutually exclusive with store and stores.
all_stores_must_succeed — when set to True, if an error occurs during the upload in at least one store, the worfklow fails, the data is deleted from stores where copying is done (not staging), and the state of the image is unchanged. When set to False, the workflow will fail (data deleted from stores, …) only if the import fails on all stores specified by the user. In case of a partial success, the locations added to the image will be the stores where the data has been correctly uploaded. Default is True.

Returns: The raw response from the request.

🌸 `stage_image`

stage_image(image, *, filename=None, data=None, size=None)

Stage binary image data.

Parameters

image — the value can be the ID of a image or an Image instance.
filename — optional name of the file to read data from.
data — optional data to be uploaded as an image.
size — optional size of the data in bytes. Providing this lets Glance pre-allocate storage and can improve staging performance. If you don’t provide it and data is a file-like object, the size will be calculated automatically.

Returns: The results of image creation.

💖 `upload_image`

upload_image(container_format=None, disk_format=None, data=None, size=None, **attrs)

Create and upload a new image from attributes.

Parameters

container_format — format of the container. A valid value is ami, ari, aki, bare, ovf, ova, or docker.
disk_format — the format of the disk. A valid value is ami, ari, aki, vhd, vmdk, raw, qcow2, vdi, or iso.
data — the data to be uploaded as an image.
attrs — keyword arguments which will be used to create a Image, comprised of the properties on the Image class.

Returns: The results of image creation.

🎀 `download_image`

download_image(image, *, stream=False, output=None, chunk_size=1048576, store_preferences=None)

Download an image.

This will download an image to memory when stream=False, or allow streaming downloads using an iterator when stream=True. For examples of working with streamed responses, see the section called Downloading an Image with stream=True (docs anchor: #download-image-stream-true) 🫶

Parameters

image — the value can be either the ID of an image or a Image instance.
stream —
- When True, return a requests.Response instance allowing you to iterate over the response data stream instead of storing its entire contents in memory. See requests.Response.iter_content() for more details.
- NOTE: If you do not consume the entirety of the response you must explicitly call requests.Response.close() or otherwise risk inefficiencies with the requests library’s handling of connections.
- When False, return the entire contents of the response.
output — either a file object or a path to store data into.
chunk_size — size in bytes to read from the wire and buffer at one time. Defaults to 1024 * 1024 = 1 MiB.
store_preferences — list of store names to prefer when downloading.

Returns: When output is not given — the bytes comprising the given Image when stream is False, otherwise a requests.Response instance. When output is given — a Image instance.

🧚 `delete_image`

delete_image(image, *, store=None, ignore_missing=True)

Delete an image.

Parameters

image — the value can be either the ID of an image or a Image instance.
store — the value can be either the ID of a store or a Store instance that the image is associated with. If specified, the image will only be deleted from the specified store.
ignore_missing — when set to False, NotFoundException will be raised when the image does not exist. When set to True, no exception will be set when attempting to delete a nonexistent image.

Returns: None

🌈 `find_image`

find_image(name_or_id, ignore_missing=True)

Find a single image.

Parameters

name_or_id — the name or ID of a image.
ignore_missing — when set to False, NotFoundException will be raised when the resource does not exist. When set to True, None will be returned when attempting to find a nonexistent resource.

Returns: one Image or None — literally just the image, or the void, no in-between bestie 💅

✨ `get_image(image)` ✨

Get a single image. One (1) image. That's the whole gig.

Parameters

image — the value can be the ID of an image or an Image instance. (yes, ID string or the whole object, both slay)

Returns: one Image

Raises NotFoundException when no resource can be found. Like, it's not hiding, it's just not there 😭

🌸 `images(**query)` 🌸

Return a generator of images — a whole lil stream of them, one at a time, no cap.

Parameters

query — optional query parameters sent along to limit the resources being returned. Use these or you're getting the entire camera roll, bestie 🫶

Returns: a generator of image objects

💖 `update_image(image, **attrs)` 💖

Update an image. Glow-up time ✨

Parameters

image — either the ID of an image or an Image instance.
attrs — the attributes to update on the image represented by image.

Returns: the updated image

🦋 `deactivate_image(image)` 🦋

Deactivate an image. It's taking a nap, do not disturb 💤

Parameters

image — either the ID of an image or an Image instance.

Returns: None

🌈 `reactivate_image(image)` 🌈

Reactivate an image. Nap's over, main character energy restored 👑

Parameters

image — either the ID of an image or an Image instance.

Returns: None

🎀 `add_tag(image, tag)` 🎀

Add a tag to an image. Little label, big personality.

Parameters

image — the value can be the ID of an image or an Image instance.
tag — the tag to be added.

Returns: None

🍓 `remove_tag(image, tag)` 🍓

Remove a tag from an image. Un-label it, respectfully.

Parameters

image — the value can be the ID of an image or an Image instance.
tag — the tag to be removed.

Returns: None

👑 Image Task Operations 👑

Okay so this whole block hangs off the same proxy class, and yes you have to look at the full signature, it's giving "terms and conditions" but make it Python 😭

class openstack.image.v2._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

💜 `image_tasks(image)` 💜

Return a generator of Image Tasks — a nice lil lazy stream of them 💫

Parameters

image — the value can be either the name of an image or an Image instance. (name or object, yes both, we love flexibility)

Returns: a generator object of image tasks

Raises NotFoundException when no resource can be found. It looked. It found nothing. It's fine. We're fine. 😭

🧚 Image Location Operations 🧚

Same proxy class, same absolutely massive signature — here it is again, because the page loves you and wants you fully informed 💅

class openstack.image.v2._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

🔥 `add_image_location(image, url, *, validation_data=None)` 🔥

Add a location to an image. It's getting a new address, congrats 🎉

Parameters

image — either the ID of an image or an Image instance.
url — a valid location url. Valid. We're being picky and honestly? Respect.
validation_data — values to be used to populate the corresponding image properties. Keyword-only, note the * bestie 🫶

Returns: the created image location

⭐ `image_locations(image)` ⭐

Get locations associated to an Image — plural, a whole little collection of addresses.

Parameters

image — either the ID of an image or an Image instance.

Returns: a generator of image location objects

💀 Member Operations 💀

Third time's the charm, here's the proxy signature again (it does not get shorter, sorry babe):

class openstack.image.v2._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

🫶 `add_member(image, **attrs)` 🫶

Create a new member from attributes. It's a whole person for your image, iconic 💖

Parameters

image — the value can be the ID of an image or an Image instance that the member will be created for.
attrs — keyword arguments which will be used to create a Member, comprised of the properties on the Member class.

See Image Sharing Reference for details: https://docs.openstack.org/api-ref/image/v2/index.html?expanded=create-image-member-detail#create-image-member

Returns: the results of member creation

🙈 `remove_member(member, image=None, ignore_missing=True)` 🙈

Delete a member. Bye bestie, no hard feelings 🌸

Parameters

member — the value can be either the ID of a member or a Member instance.
image — the value can be either the ID of an image or an Image instance that the member is part of. This is required if member is an ID. Like, an ID alone doesn't tell us where to look, yk? 🔍
ignore_missing — when set to False, NotFoundException will be raised when the member does not exist. When set to True, no exception will be set when attempting to delete a nonexistent member. (Default is True, so by default we simply do not care 💅)

Returns: None

🎀 `find_member(name_or_id, image, ignore_missing=True)` 🎀

Find a single member. Just the one. Scavenger hunt, but polite.

Parameters

name_or_id — the name or ID of a member.
image — this is the image that the member belongs to, the value can be the ID of an image or an Image instance.
ignore_missing — when set to False, NotFoundException will be raised when the resource does not exist. When set to True, None will be returned when attempting to find a nonexistent resource. (Different flavour of "missing" handling than remove_member, don't mix them up!)

Returns: one Member or None

🦋 `get_member(member, image)` 🦋

Get a single member on an image. Specific member, specific image, very intentional.

Parameters

member — the value can be the ID of a member or a Member instance.
image — this is the image that the member belongs to. The value can be the ID of an image or an Image instance.

Returns: one Member

Raises NotFoundException when no resource can be found. Again. It's a whole theme 🔥

🌈 `members(image, **query)` 🌈

Return a generator of members — all the friends of this image, streamed one by one.

Parameters

image — this is the image that the member belongs to, the value can be the ID of an image or an Image instance.
query — optional query parameters to be sent to limit the resources being returned.

Returns: a generator of member objects

💜 `update_member(member, image, **attrs)` 💜

Update the member of an image. Little refresh, little glow-up ✨

Parameters

member — either the ID of a member or a Member instance.

Continuing the update_member deets, bestie:

image — the image that this member belongs to. The value can be the ID of an image, or an openstack.image.v2.image.Image instance. 🖼️
attrs — the attributes you want to update on the member represented by member.

See the Image Sharing Reference at https://docs.openstack.org/api-ref/image/v2/index.html?expanded=update-image-member-detail#update-image-member for the full tea. ☕

Returns: the updated member ✨

🛠️ Task Operations 🛠️

Same Proxy energy, same constructor signature — no cap:

class openstack.image.v2._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

`tasks(**query)`

Return a generator of tasks. 🌀

Parameters: query — optional query parameters sent along to limit the resources being returned.

Returns: a generator of task objects.

`get_task(task)`

Get task details. 🔍

Parameters: task — the value can be the ID of a task or an openstack.image.v2.task.Task instance.

Returns: one Task (openstack.image.v2.task.Task).

Raises: openstack.exceptions.NotFoundException when no resource can be found. 😭

`create_task(**attrs)`

Create a new task from attributes. 🎀

Parameters: attrs — keyword arguments used to create a Task (openstack.image.v2.task.Task), made up of the properties on the Task class.

Returns: the results of task creation.

`wait_for_task(task, status='success', failures=None, interval=2, wait=120)`

Wait for a task to be in a particular status. ⏳

Parameters:

task — the resource to wait on until it reaches the specified status. The resource must have a status attribute.
status — desired status.
failures (list) — statuses that would be interpreted as failures.
interval — number of seconds to wait between consecutive checks. Defaults to 2.
wait — maximum number of seconds to wait before the change. Defaults to 120.

Returns: the resource is returned on success. 🫶

Raises: openstack.exceptions.ResourceTimeout if the transition to the desired status failed to occur in the specified seconds.

Raises: openstack.exceptions.ResourceFailure if the resource has transited to one of the failure statuses.

Raises: AttributeError if the resource does not have a status attribute. 💀

📐 Schema Operations 📐

Again, same Proxy constructor signature — iconic, unchanged:

class openstack.image.v2._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

`get_metadef_tags_schema()`

Get metadata definition tags schema.

Returns: one MetadefSchema (openstack.image.v2.metadef_schema.MetadefSchema).

Raises: openstack.exceptions.NotFoundException when no resource can be found.

🔍 Service Info Discovery Operations 🔍

And one more time, the Proxy constructor signature stays serving looks:

class openstack.image.v2._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

`stores(details=False, **query)`

Return a generator of supported image stores. 🛍️

Returns — a generator of store objects 🛍️✨

`get_import_info()`

Okay so this one is giving “tell me the image constraints” energy. It gets a info about image constraints (yes, “a info” — we keep the source’s grammar exactly, bestie 💅).

Returns — One Import <#openstack.image.v2.service_info.Import> 🎀

Raises — NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found.

🧚 Metadef Namespace Operations

class openstack.image.v2._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

`create_metadef_namespace(**attrs)`

Create a new metadef namespace from attributes. New namespace, who dis? ✨

Parameters

attrs — Keyword arguments which will be used to create a MetadefNamespace <#openstack.image.v2.metadef_namespace.MetadefNamespace> comprised of the properties on the MetadefNamespace class.

Returns — The results of metadef namespace creation.

`delete_metadef_namespace(metadef_namespace, ignore_missing=True)`

Delete a metadef namespace. Poof, gone — but only if you actually mean it 🫶

Parameters

metadef_namespace — The value can be either the name of a metadef namespace or a MetadefNamespace <#openstack.image.v2.metadef_namespace.MetadefNamespace> instance.
ignore_missing — When set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the metadef namespace does not exist.

Returns — None

`get_metadef_namespace(metadef_namespace)`

Get a single metadef namespace. Main-character retrieval behavior, honestly 👑

Parameters

metadef_namespace — Either the name of a metadef namespace or an MetadefNamespace <#openstack.image.v2.metadef_namespace.MetadefNamespace> instance.

Returns — One MetadefNamespace <#openstack.image.v2.metadef_namespace.MetadefNamespace>

Raises — NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found.

`metadef_namespaces(**query)`

Return a generator of metadef namespaces. It’s giving infinite scroll, but for namespaces 🌈

Returns — A generator object of metadef namespaces.

Raises — NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found.

`update_metadef_namespace(metadef_namespace, **attrs)`

Update a server. Yes, the original description literally says “server” here — we are simply reporting the lore, bestie 😭💀

Parameters

metadef_namespace — Either the name of a metadef namespace or an MetadefNamespace <#openstack.image.v2.metadef_namespace.MetadefNamespace> instance.
attrs — The attributes to update on the metadef namespace represented by metadef_namespace.

Returns — The updated metadef namespace.

🦋 Metadef Object Operations

class openstack.image.v2._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

`create_metadef_object(namespace, **attrs)`

Create a new object from namespace. New object, who dis? 💫

Parameters

namespace — The value can be either the name of a metadef namespace or a MetadefNamespace <#openstack.image.v2.metadef_namespace.MetadefNamespace> instance.
attrs — Keyword arguments which will be used to create a MetadefObject <#openstack.image.v2.metadef_object.MetadefObject>, comprised of the properties on the Metadef object class.

Returns — A metadef namespace.

`get_metadef_object(metadef_object, namespace)`

Get a single metadef object. One object, zero chaos (ideally) 🎀

Parameters

metadef_object — The value can be the ID of a metadef_object or a MetadefObject <#openstack.image.v2.metadef_object.MetadefObject> instance.
namespace — The value can be either the name of a metadef namespace or a MetadefNamespace <#openstack.image.v2.metadef_namespace.MetadefNamespace> instance.

Returns — One MetadefObject <#openstack.image.v2.metadef_object.MetadefObject>

Raises — NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found.

`metadef_objects(namespace)`

Get metadef object list of the namespace. The source says it returns One MetadefObject — singular, iconic, no cap 💅

Parameters

namespace — The value can be either the name of a metadef namespace or a MetadefNamespace <#openstack.image.v2.metadef_namespace.MetadefNamespace> instance.

Returns — One MetadefObject <#openstack.image.v2.metadef_object.MetadefObject>

Raises — NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found.

`update_metadef_object(metadef_object, namespace, **attrs)`

Update a single metadef object. Glow-up arc, but for metadata ✨

Parameters

metadef_object — The value can be the ID of a metadef_object or a MetadefObject <#openstack.image.v2.metadef_object.MetadefObject> instance.
namespace — The value can be either the name of a metadef namespace or a MetadefNamespace <#openstack.image.v2.metadef_namespace.MetadefNamespace> instance.
attrs — Keyword arguments which will be used to update a MetadefObject <#openstack.image.v2.metadef_object.MetadefObject>

Returns — One MetadefObject <#openstack.image.v2.metadef_object.MetadefObject>

Raises — NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found.

`delete_metadef_object(metadef_object, namespace, **attrs)`

Removes a single metadef object. Bye bestie, we hardly knew ye 🫡

Parameters

metadef_object — The value can be the ID of a metadef_object or a MetadefObject <#openstack.image.v2.metadef_object.MetadefObject> instance.
namespace — The value can be either the name of a metadef namespace or a MetadefNamespace <#openstack.image.v2.metadef_namespace.MetadefNamespace> instance.
attrs — Keyword arguments which will be used to update a MetadefObject <#openstack.image.v2.metadef_object.MetadefObject>

Returns — The deleted metadef object.

Raises — NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found.

💜 Metadef Resource Type Operations

class openstack.image.v2._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

`metadef_resource_types(**query)`

Return a generator of metadef resource types. Resource-type generator realness 🌸

Returns — A generator object of metadef resource types MetadefResourceType <#openstack.image.v2.metadef_resource_type.MetadefResourceType>

Raises — NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found.

`create_metadef_resource_type_association(metadef_namespace, **attrs)`

Creates a resource type association between a namespace and the resource type specified in the body of the request. That’s the whole description, bestie — no extra Returns or Raises listed here 🎀

Parameters

attrs — the keyword args that get used to create a MetadefResourceTypeAssociation <#openstack.image.v2.metadef_resource_type.MetadefResourceTypeAssociation>, built from the properties on the MetadefResourceTypeAssociation class.

Returns

The results of metadef resource type association creation ✨

💅 `delete_metadef_resource_type_association(metadef_resource_type, metadef_namespace, ignore_missing=True)`

Removes a resource type association from a namespace. Bye bestie 👋

Parameters

metadef_resource_type — can be either the name of a metadef resource type association or a MetadefResourceTypeAssociation <#openstack.image.v2.metadef_resource_type.MetadefResourceTypeAssociation> instance.
metadef_namespace — can be either the name of the metadef namespace or a MetadefNamespace <#openstack.image.v2.metadef_namespace.MetadefNamespace> instance.
ignore_missing — when set to False, a NotFoundException <#openstack.exceptions.NotFoundException> gets raised if the metadef resource type association doesn't exist.

Returns

None

🦋 `metadef_resource_type_associations(metadef_namespace, **query)`

Hands you back a generator of metadef resource type associations.

Parameters

metadef_namespace — can be either the name of the metadef namespace or a MetadefNamespace <#openstack.image.v2.metadef_namespace.MetadefNamespace> instance.

Returns

A generator object of metadef resource type associations, MetadefResourceTypeAssociation <#openstack.image.v2.metadef_resource_type.MetadefResourceTypeAssociation>.

Raises NotFoundException <#openstack.exceptions.NotFoundException> when nothing can be found. 😭

🧚 Metadef Property Operations 🧚

class openstack.image.v2._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

🌸 `create_metadef_property(metadef_namespace, **attrs)`

Makes a metadef property. New property just dropped 💅

Parameters

metadef_namespace — can be either the name of the metadef namespace or a MetadefNamespace instance.
attrs — the attributes to create on the metadef property represented by metadef_property.

Returns

The created metadef property ✨

🎀 `update_metadef_property(metadef_property, metadef_namespace, **attrs)`

Updates a metadef property — glow-up time.

Parameters

metadef_property — can be either the name of the metadef property or a MetadefProperty <#openstack.image.v2.metadef_property.MetadefProperty> instance.
metadef_namespace — can be either the name of the metadef namespace or a MetadefNamespace <#openstack.image.v2.metadef_namespace.MetadefNamespace> instance.
attrs — the attributes to update on the metadef property represented by metadef_property.

Returns

The updated metadef property ✨

🫶 `delete_metadef_property(metadef_property, metadef_namespace, ignore_missing=True)`

Deletes a metadef property. It's giving closure 🕊️

Parameters

metadef_property — can be either the name of the metadef property or a MetadefProperty <#openstack.image.v2.metadef_property.MetadefProperty> instance.
metadef_namespace — can be either the name of the metadef namespace or a MetadefNamespace <#openstack.image.v2.metadef_namespace.MetadefNamespace> instance.
ignore_missing — when set to False, a NotFoundException <#openstack.exceptions.NotFoundException> gets raised if the instance doesn't exist. When set to True, no exception gets set when you try to delete a nonexistent instance.

Returns

None

🍓 `get_metadef_property(metadef_property, metadef_namespace, **query)`

Gets you a single metadef property.

Parameters

metadef_property — can be either the name of the metadef property or a MetadefProperty <#openstack.image.v2.metadef_property.MetadefProperty> instance.
metadef_namespace — can be either the name of the metadef namespace or a MetadefNamespace <#openstack.image.v2.metadef_namespace.MetadefNamespace> instance.

Returns

One MetadefProperty <#openstack.image.v2.metadef_property.MetadefProperty>

Raises NotFoundException <#openstack.exceptions.NotFoundException> when nothing can be found. 😭

⭐ Helpers ⭐

class openstack.image.v2._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

💜 `wait_for_delete(res, interval=2, wait=120, callback=None)`

Waits for a resource to be deleted. Bestie is very patient, but not infinitely patient, iykyk 👑

Parameters

res — the resource you're waiting on to be deleted.
interval — number of seconds to wait before consecutive checks.
wait — maximum number of seconds to wait before the change.
callback — a callback function. This gets called with a single value, progress, which is a percentage value from 0-100.

Returns

The resource gets returned on success.

Raises ResourceTimeout <#openstack.exceptions.ResourceTimeout> if the transition to delete failed to occur in the specified seconds. 💀

🌈 Cache Operations 🌈

class openstack.image.v2._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

🦋 `cache_delete_image(image, ignore_missing=True)`

Deletes an image from cache. Not me evicting my exes from the group chat 🙈

Parameters

image — can be either the ID of an image or an Image <#openstack.image.v2.image.Image> instance.
ignore_missing — when set to False, a NotFoundException <#openstack.exceptions.NotFoundException> gets raised if the image or the cache entry doesn't exist.

Returns

None

✨ `queue_image(image)`

Queues image(s) for caching. Get in line, bestie 🎟️

🧚 `clear_cache(target='both')`

Clears all images from cache, queue, or both. Spring cleaning fr fr 🧹

Parameters

target — specify which target you wanna clear. One of: both (default), cache, queue.

👑 KeyManager API 👑

For deets on how to use key_management, see Using OpenStack Key Manager <> 🌸

🔥 The KeyManager Class 🔥

The key_management high-level interface is available through the key_manager member of a Connection <#openstack.connection.Connection> object. The key_manager member only gets added if the service is detected. 💅

✨ Secret Operations ✨

Bestie, this is the secret-handling corner of the proxy. The class signature is literally this big thing:

class openstack.key_manager.v1._proxy.Proxy(session, *,
       service_type=None, service_name=None, interface=None, region_name=None,
       endpoint_override=None, version=None, auth=None, user_agent=None,
       connect_retries=None, logger=None, allow=None, additional_headers=None,
       client_name=None, client_version=None, allow_version_hack=None,
       global_request_id=None, min_version=None, max_version=None,
       default_microversion=None, status_code_retries=None,
       retriable_status_codes=None, raise_exc=None, rate_limit=None,
       concurrency=None, connect_retry_delay=None,
       status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
       prometheus_counter=None, prometheus_histogram=None,
       influxdb_config=None, influxdb_client=None)

create_secret(**attrs) — Create a new secret from attributes 💖

attrs — Keyword arguments which will be used to create a Secret <#openstack.key_manager.v1.secret.Secret>, comprised of the properties on the Order class.

Returns: The results of secret creation ✨

delete_secret(secret, ignore_missing=True) — Delete a secret 🫶

Parameters

secret — The value can be either the ID of a secret or a Secret <#openstack.key_manager.v1.secret.Secret> instance.
ignore_missing — When set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the secret does not exist. When set to True, no exception will be set when attempting to delete a nonexistent secret.

Returns: None

find_secret(name_or_id, ignore_missing=True) — Find a single secret 🔎

Parameters

name_or_id — The name or ID of a secret.
ignore_missing — When set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the resource does not exist. When set to True, None will be returned when attempting to find a nonexistent resource.

Returns: One Secret <#openstack.key_manager.v1.secret.Secret> or None

get_secret(secret) — Get a single secret 💅

Parameters

secret — The value can be the ID of a secret or a Secret <#openstack.key_manager.v1.secret.Secret> instance.

Returns: One Secret <#openstack.key_manager.v1.secret.Secret>

Raises: NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found.

secrets(**query) — Return a generator of secrets 🌈

Parameters

query — Optional query parameters to be sent to limit the resources being returned.

Returns: A generator of secret objects

update_secret(secret, **attrs) — Update a secret ⭐

Parameters

secret — Either the id of a secret or a Secret <#openstack.key_manager.v1.secret.Secret> instance.
attrs — The attributes to update on the secret represented by secret.

Returns: The updated secret

🌸 Container Operations 🌸

Same big class signature, now for container business:

class openstack.key_manager.v1._proxy.Proxy(session, *,
       service_type=None, service_name=None, interface=None, region_name=None,
       endpoint_override=None, version=None, auth=None, user_agent=None,
       connect_retries=None, logger=None, allow=None, additional_headers=None,
       client_name=None, client_version=None, allow_version_hack=None,
       global_request_id=None, min_version=None, max_version=None,
       default_microversion=None, status_code_retries=None,
       retriable_status_codes=None, raise_exc=None, rate_limit=None,
       concurrency=None, connect_retry_delay=None,
       status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
       prometheus_counter=None, prometheus_histogram=None,
       influxdb_config=None, influxdb_client=None)

create_container(**attrs) — Create a new container from attributes 🎀

Parameters

attrs — Keyword arguments which will be used to create a Container <#openstack.key_manager.v1.container.Container>, comprised of the properties on the Container class.

Returns: The results of container creation

delete_container(container, ignore_missing=True) — Delete a container 💀

Parameters

container — The value can be either the ID of a container or a Container <#openstack.key_manager.v1.container.Container> instance.
ignore_missing — When set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the container does not exist. When set to True, no exception will be set when attempting to delete a nonexistent container.

Returns: None

find_container(name_or_id, ignore_missing=True) — Find a single container 🦋

Parameters

name_or_id — The name or ID of a container.
ignore_missing — When set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the resource does not exist. When set to True, None will be returned when attempting to find a nonexistent resource.

Returns: One Container <#openstack.key_manager.v1.container.Container> or None

get_container(container) — Get a single container 💜

Parameters

container — The value can be the ID of a container or a Container <#openstack.key_manager.v1.container.Container> instance.

Returns: One Container <#openstack.key_manager.v1.container.Container>

Raises: NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found.

containers(**query) — Return a generator of containers 🧚

Parameters

query — Optional query parameters to be sent to limit the resources being returned.

Returns: A generator of container objects

update_container(container, **attrs) — Update a container 🌟

Parameters

container — Either the id of a container or a Container <#openstack.key_manager.v1.container.Container> instance.
attrs — The attributes to update on the container represented by container.

Returns: The updated container

🎀 Container ACL Operations 🎀

And here's the class signature one more time, because the ACL glow-up deserves it:

class openstack.key_manager.v1._proxy.Proxy(session, *,
       service_type=None, service_name=None, interface=None, region_name=None,
       endpoint_override=None, version=None, auth=None, user_agent=None,
       connect_retries=None, logger=None, allow=None, additional_headers=None,
       client_name=None, client_version=None, allow_version_hack=None,
       global_request_id=None, min_version=None, max_version=None,
       default_microversion=None, status_code_retries=None,
       retriable_status_codes=None, raise_exc=None, rate_limit=None,
       concurrency=None, connect_retry_delay=None,
       status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
       prometheus_counter=None, prometheus_histogram=None,
       influxdb_config=None, influxdb_client=None)

get_container_acl(container) — Get a container's ACL settings 🔐

Parameters

container — The value can be the ID of a container or a Container <#openstack.key_manager.v1.container.Container> instance.

Returns: One container ACL

create_container_acl(container, **attrs) — Create or replace a container's ACL 👑

Parameters

container — The value can be the ID of a container or a Container <#openstack.key_manager.v1.container.Container> instance.
attrs — Keyword arguments which will be used to create a ContainerACL <#openstack.key_manager.v1.container_acl.ContainerACL>, comprised of the properties on the ContainerACL class. The ACL body must be supplied explicitly, typically as a read dict, e.g. read={'users': ['user-id'], 'project-access': False}.

Returns: The results of ACL creation

update_container_acl(container, **attrs) — Update a container's ACL 💫

Parameters

container — The value can be the ID of a container or a Container <#openstack.key_manager.v1.container.Container> instance.
attrs — The attributes to update on the ACL. The ACL body must be supplied explicitly, typically as a read dict, e.g. read={'users': ['user-id'], 'project-access': True}.

Returns: The updated ACL

delete_container_acl(container, ignore_missing=True) — Reset a container's ACL to default settings 🧹

Parameters

container — the container you're nuking. Slug in the ID of a container, or hand over an actual Container instance (<#openstack.key_manager.v1.container.Container>) and let the SDK do the heavy lifting 💅
ignore_missing — set it to False and you get a NotFoundException (<#openstack.exceptions.NotFoundException>) thrown at you the second the container doesn't exist. Set it to True and the SDK is just gonna vibe — no exception, no drama, even if you're deleting a container that was never a thing 🫶

Returns — None. That's it, that's the whole return value, bestie.

Order Operations

class openstack.key_manager.v1._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

create_order(**attrs)

Cooks up a brand-new order straight from its attributes ✨

Parameters

attrs — keyword args that get used to build an Order (<#openstack.key_manager.v1.order.Order>). Basically every property on the Order class, so go off 👑

Returns — the results of order creation. The fresh new order, looking all cute.

delete_order(order, ignore_missing=True)

Yeets an order into the void 🗑️

Parameters

order — either the ID of an order, or an Order (<#openstack.key_manager.v1.order.Order>) instance.
ignore_missing — False means a NotFoundException (<#openstack.exceptions.NotFoundException>) gets raised when the order doesn't exist. True means no exception gets set even when you attempt to delete a nonexistent order. No notes, just vibes 🙈

Returns — None.

find_order(name_or_id, ignore_missing=True)

Finds you a single order, like a lil scavenger hunt 🦋

Parameters

name_or_id — the name or ID of a order.
ignore_missing — False → NotFoundException (<#openstack.exceptions.NotFoundException>) raised when the resource doesn't exist. True → you get None back when attempting to find a nonexistent resource. Gentle. Kind. Iconic.

Returns — one Order (<#openstack.key_manager.v1.order.Order>) or None.

get_order(order)

Grabs a single order, no searching around 💖

Parameters

order — the ID of an order, or an Order (<#openstack.key_manager.v1.order.Order>) instance.

Returns — one Order (<#openstack.key_manager.v1.order.Order>).

Raises — NotFoundException (<#openstack.exceptions.NotFoundException>) when no resource can be found. 😭

orders(**query)

Hands you back a generator of orders, all lined up 🌈

Parameters

query — optional query params you can send along to limit the resources being returned. Filter away, bestie.

Returns — a generator of order objects.

update_order(order, **attrs)

Glow-up time — updates a order 💅

Parameters

order — either the id of a order or an Order (<#openstack.key_manager.v1.order.Order>) instance.
attrs — the attributes to update on the order represented by order.

Returns — the updated order. Look at her now 🔥

Quota Operations

class openstack.key_manager.v1._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

get_project_quota(project)

Get a single project quota — one project, one quota, very monogamous of you 🎀

Parameters

project — a project ID or a Project (<#openstack.identity.v3.project.Project>) instance.

Returns — one ProjectQuota (<#openstack.key_manager.v1.project_quota.ProjectQuota>).

Raises — NotFoundException (<#openstack.exceptions.NotFoundException>) when no resource can be found 💀

get_quota()

Gets the effective quotas for the current project — the real real, not the theoretical ✨

Returns — one Quota (<#openstack.key_manager.v1.quota.Quota>).

Raises — NotFoundException (<#openstack.exceptions.NotFoundException>) when no resource can be found.

Secret Store Operations

class openstack.key_manager.v1._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

secret_stores(**query)

Returns a generator of secret stores — yes bestie, a whole generator, lazy and efficient, we love to see it 🧚

Parameters

query — optional query parameters to be sent along to limit the resources being returned.

Returns — a generator of secret store objects.

get_global_default_secret_store()

Gets the global default secret store, the main character of secret stores 👑

Returns — one SecretStore (<#openstack.key_manager.v1.secret_store.SecretStore>).

Raises — NotFoundException (<#openstack.exceptions.NotFoundException>) when no resource can be found. 😭

get_preferred_secret_store()

Gets the preferred secret store for the current project — this project's personal fave 🌸

Returns — one SecretStore (<#openstack.key_manager.v1.secret_store.SecretStore>).

Raises — NotFoundException (<#openstack.exceptions.NotFoundException>) when no resource can be found.

ProjectQuota Operations

class openstack.key_manager.v1._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

delete_project_quota(project, ignore_missing=True)

Deletes a project quota 🗑️✨

Parameters

project — a project ID or a Project (<#openstack.identity.v3.project.Project>) instance.
ignore_missing — False means a NotFoundException (<#openstack.exceptions.NotFoundException>) gets raised when the project quota doesn't exist. True means no exception gets set when you attempt to delete a nonexistent project quota. Chill mode: activated 🫶

Returns — None.

get_project_quota(project)

Get a single project quota, one (1) quota, freshly fetched 💜

Parameters

project — a project ID or a Project (<#openstack.identity.v3.project.Project>) instance.

Returns — one ProjectQuota (<#openstack.key_manager.v1.project_quota.ProjectQuota>).

Raises — NotFoundException (<#openstack.exceptions.NotFoundException>) when no resource can be found.

update_project_quota(project, **attrs)

Updates a project quota — new quota, who dis 💅

Parameters

project — a project ID or a Project (<#openstack.identity.v3.project.Project>) instance.
attrs — the attributes to update on the project quota represented by project quota.

Returns — the updated project quota 🔥

✨ Secret ACL Operations ✨

Okay bestie, so first up we have the class openstack.key_manager.v1._proxy.Proxy — and yes, the signature is a whole mood, so here it is in all its glory:

class openstack.key_manager.v1._proxy.Proxy(session, *,
       service_type=None, service_name=None, interface=None, region_name=None,
       endpoint_override=None, version=None, auth=None, user_agent=None,
       connect_retries=None, logger=None, allow=None, additional_headers=None,
       client_name=None, client_version=None, allow_version_hack=None,
       global_request_id=None, min_version=None, max_version=None,
       default_microversion=None, status_code_retries=None,
       retriable_status_codes=None, raise_exc=None, rate_limit=None,
       concurrency=None, connect_retry_delay=None,
       status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
       prometheus_counter=None, prometheus_histogram=None,
       influxdb_config=None, influxdb_client=None)

get_secret_acl(secret) — Gets the ACL of a secret. No cap, it's giving "let me see who's allowed".
- Parameters:
  - secret — Secret ID or a Secret instance (the openstack.key_manager.v1.secret.Secret class).
- Returns: SecretACL (the openstack.key_manager.v1.secret_acl.SecretACL class) whose read contains the ACL. If no explicit ACL exists, the default ACL is returned.
- Raises: NotFoundException (the openstack.exceptions.NotFoundException class)
set_secret_acl(secret, **attrs) — Set (replace) the ACL of a secret (PUT). It's a full glow-up replacement, bestie.
- Parameters:
  - secret — Secret ID or Secret instance.
  - attrs — ACL body, typically a read dict.
- Returns: SecretACL (the openstack.key_manager.v1.secret_acl.SecretACL class) whose acl_ref references the ACL URL.
update_secret_acl(secret, **attrs) — Partially update the ACL of a secret (PATCH). Lowkey just tweaking, not a full rewrite.
- Parameters:
  - secret — Secret ID or Secret instance.
  - attrs — Partial ACL body, typically a read dict.
- Returns: SecretACL (the openstack.key_manager.v1.secret_acl.SecretACL class) whose acl_ref references the ACL URL.
delete_secret_acl(secret, ignore_missing=True) — Delete the ACL of a secret. Bye bye, ACL! 👋
- Parameters:
  - secret — Secret ID or Secret instance.
  - ignore_missing — When set to False, raise if not found.
- Returns: None
- Raises: NotFoundException (the openstack.exceptions.NotFoundException class)

✨ Secret Consumer Operations ✨

Same iconic class signature, because consistency is key:

class openstack.key_manager.v1._proxy.Proxy(session, *,
       service_type=None, service_name=None, interface=None, region_name=None,
       endpoint_override=None, version=None, auth=None, user_agent=None,
       connect_retries=None, logger=None, allow=None, additional_headers=None,
       client_name=None, client_version=None, allow_version_hack=None,
       global_request_id=None, min_version=None, max_version=None,
       default_microversion=None, status_code_retries=None,
       retriable_status_codes=None, raise_exc=None, rate_limit=None,
       concurrency=None, connect_retry_delay=None,
       status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
       prometheus_counter=None, prometheus_histogram=None,
       influxdb_config=None, influxdb_client=None)

create_secret_consumer(secret, **attrs) — Create a consumer for a secret. It's giving "let's link this secret to a service".
- Parameters:
  - secret — Either the id of a secret or a Secret instance (the openstack.key_manager.v1.secret.Secret class).
  - attrs — Must include service, resource_type, resource_id.
- Returns: The created consumer association.
delete_secret_consumer(secret, ignore_missing=True, **attrs) — Delete a consumer association from a secret. Unlinking, bestie.
- Parameters:
  - secret — Either the id of a secret or a Secret instance (the openstack.key_manager.v1.secret.Secret class).
  - ignore_missing — When set to False, NotFoundException (the openstack.exceptions.NotFoundException class) will be raised when the secret does not exist. When set to True, no exception will be set when attempting to delete a nonexistent secret.
  - attrs — Must include service, resource_type, resource_id.
- Returns: None
secret_consumers(secret, **query) — List consumers for a secret. Get the whole squad of consumers.
- Parameters:
  - secret — Either the id of a secret or a Secret instance (the openstack.key_manager.v1.secret.Secret class).
- Returns: A generator of SecretConsumer objects.

✨ Load Balancer v2 API ✨

The LoadBalancer Class

Okay so the load_balancer high-level interface? It's literally available through the load_balancer member of a Connection object (that's the openstack.connection.Connection class). But heads up: the load_balancer member will only be added if the service is detected. No service, no member. Periodt.

Load Balancer Operations

And here's the class signature for this one — yes, it's long, but we keep it exact:

class openstack.load_balancer.v2._proxy.Proxy(session, *,
       service_type=None, service_name=None, interface=None, region_name=None,
       endpoint_override=None, version=None, auth=None, user_agent=None,
       connect_retries=None, logger=None, allow=None, additional_headers=None,
       client_name=None, client_version=None, allow_version_hack=None,
       global_request_id=None, min_version=None, max_version=None,
       default_microversion=None, status_code_retries=None,
       retriable_status_codes=None, raise_exc=None, rate_limit=None,
       concurrency=None, connect_retry_delay=None,
       status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
       prometheus_counter=None, prometheus_histogram=None,
       influxdb_config=None, influxdb_client=None)

create_load_balancer(**attrs) — Create a new load balancer from attributes. It's a whole new LB, slay.
- Parameters:
  - attrs — Keyword arguments which will be used to create a LoadBalancer (the openstack.load_balancer.v2.load_balancer.LoadBalancer class), comprised of the properties on the LoadBalancer class.
- Returns: The results of load balancer creation.
get_load_balancer(load_balancer) — Get a load balancer. Fetching the LB details.
- Parameters:
  - load_balancer — The value can be the ID of a load balancer or a LoadBalancer instance (the openstack.load_balancer.v2.load_balancer.LoadBalancer class).
- Returns: One LoadBalancer (the openstack.load_balancer.v2.load_balancer.LoadBalancer class).
get_load_balancer_statistics(load_balancer) — Get the load balancer statistics. Stats, bestie!
- Parameters:
  - load_balancer — The value can be the ID of a load balancer or a LoadBalancer instance (the openstack.load_balancer.v2.load_balancer.LoadBalancer class).
- Returns: One LoadBalancerStats (the openstack.load_balancer.v2.load_balancer.LoadBalancerStats class).
load_balancers(**query) — Retrieve a generator of load balancers. All the LBs, coming right up.
- Returns: A generator of load balancer instances.
delete_load_balancer(load_balancer, ignore_missing=True, cascade=False) — Delete a load balancer. 🗑️
- Parameters:
  - load_balancer — The load_balancer can be either the ID or a LoadBalancer instance (the openstack.load_balancer.v2.load_balancer.LoadBalancer class).
  - ignore_missing — When set to False, NotFoundException (the openstack.exceptions.NotFoundException class) will be raised when the load balancer does not exist. When set to True, no exception will be set when attempting to delete a nonexistent load balancer.
  - cascade — If true will delete all child objects of the load balancer.
- Returns: None
find_load_balancer(name_or_id, ignore_missing=True) — Find a single load balancer. Like a search but for one LB.
- Parameters:
  - name_or_id — The name or ID of a load balancer.
  - ignore_missing — When set to False, NotFoundException (the openstack.exceptions.NotFoundException class) will be raised when the load balancer does not exist. When set to True, no exception will be set when attempting to find a nonexistent load balancer.
- Returns: None
update_load_balancer(load_balancer, **attrs) — Update a load balancer. Glow-up time.
- Parameters:
  - load_balancer — The load_balancer can be either the ID or a LoadBalancer instance (the openstack.load_balancer.v2.load_balancer.LoadBalancer class).
  - attrs — The attributes to update on the load balancer represented by load_balancer.
- Returns: The updated load_balancer.
wait_for_load_balancer(name_or_id, status='ACTIVE', failures=['ERROR'], interval=2, wait=300) — Wait for load balancer status. It's giving "are we there yet?" but for LBs.
- Parameters:
  - name_or_id — The name or ID of the load balancer.
  - status — Desired status.
  - failures (list) — Statuses that would be interpreted as failures. Default to ['ERROR'].
  - interval — Number of seconds to wait between consecutive checks. Defaults to 2.
  - wait — Maximum number of seconds to wait before the status to be reached. Defaults to 300.
- Returns: The load balancer is returned on success.
Raises ResourceTimeout <#openstack.exceptions.ResourceTimeout> if the transition to the status you want just... didn't happen inside the wait time you gave it. 😭
Raises ResourceFailure <#openstack.exceptions.ResourceFailure> if the resource has walked itself over to one of the failure statuses. yikes.
Raises AttributeError if the resource doesn't even have a status attribute, bestie. like it's not even in the chat. 💀
failover_load_balancer(load_balancer) — Failover a load balancer. dramatic but necessary ✨

Parameters

load_balancer — the value can be the ID of a load balancer or a LoadBalancer <#openstack.load_balancer.v2.load_balancer.LoadBalancer> instance.

Returns

None

🌸 Listener Operations 🌸

class openstack.load_balancer.v2._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

(yeah that's the whole constructor again, unedited, no cap — copy it exactly if you're writing it down somewhere 💅)

create_listener(**attrs) — Create a new listener from attributes. it's giving new-listener energy 🎀

Parameters

attrs — keyword arguments which will be used to create a Listener <#openstack.load_balancer.v2.listener.Listener>, comprised of the properties on the Listener class.

Returns

The results of listener creation

delete_listener(listener, ignore_missing=True) — Delete a listener. bye girl 🦋

Parameters

listener — the value can be either the ID of a listener or a Listener <#openstack.load_balancer.v2.listener.Listener> instance.
ignore_missing — when set to False NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the listner does not exist. When set to True, no exception will be set when attempting to delete a nonexistent listener.

Returns

None

find_listener(name_or_id, ignore_missing=True) — Find a single listener. detective mode 🔍

Parameters

name_or_id — the name or ID of a listener.
ignore_missing — when set to False NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the resource does not exist. When set to True, None will be returned when attempting to find a nonexistent resource.

Returns

One Listener <#openstack.load_balancer.v2.listener.Listener> or None

get_listener(listener) — Get a single listener.

Parameters

listener — the value can be the ID of a listener or a Listener <#openstack.load_balancer.v2.listener.Listener> instance.

Returns

One Listener <#openstack.load_balancer.v2.listener.Listener>

Raises NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found. 😭

get_listener_statistics(listener) — Get the listener statistics. numbers girlies rise 💅

Parameters

listener — the value can be the ID of a listener or a Listener <#openstack.load_balancer.v2.listener.Listener> instance.

Returns

One ListenerStats <#openstack.load_balancer.v2.listener.ListenerStats>

Raises NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found.

listeners(**query) — Return a generator of listeners. a whole little lineup ✨

Parameters

query — optional query parameters to be sent to limit the resources being returned. Valid parameters are:

Returns

A generator of listener objects

update_listener(listener, **attrs) — Update a listener. glow-up time 🌈

Parameters

listener — either the id of a listener or a Listener <#openstack.load_balancer.v2.listener.Listener> instance.
attrs — the attributes to update on the listener represented by listener.

Returns

The updated listener

🫶 Pool Operations 🫶

class openstack.load_balancer.v2._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

(same constructor, character for character — iconic of her honestly)

create_pool(**attrs) — Create a new pool from attributes. pool party 🏊‍♀️

Parameters

attrs — keyword arguments which will be used to create a Pool <#openstack.load_balancer.v2.pool.Pool>, comprised of the properties on the Pool class.

Returns

The results of Pool creation

get_pool(pool) — Get a pool.

Parameters

pool — value is either a pool ID or a Pool <#openstack.load_balancer.v2.pool.Pool> instance.

Returns

One Pool <#openstack.load_balancer.v2.pool.Pool>

pools(**query) — Retrieve a generator of pools.

Returns

A generator of Pool instances

delete_pool(pool, ignore_missing=True) — Delete a pool.

Parameters

pool — the pool is either a pool ID or a Pool <#openstack.load_balancer.v2.pool.Pool> instance
ignore_missing — when set to False NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the pool does not exist. When set to True, no exception will be set when attempting to delete a nonexistent pool.

Returns

The deleted pool.

find_pool(name_or_id, ignore_missing=True) — Find a single pool.

Parameters

name_or_id — the name or ID of a pool
ignore_missing — when set to False NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the pool does not exist. When set to True, no exception will be set when attempting to find a nonexistent pool.

Returns

None

update_pool(pool, **attrs) — Update a pool.

Parameters

pool — either the id of a pool or a Pool <#openstack.load_balancer.v2.pool.Pool> instance.
attrs — the attributes to update on the pool represented by pool.

Returns

The updated pool

💜 Member Operations 💜

class openstack.load_balancer.v2._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

(yes bestie, the exact same one, do not retype it from memory 😭)

create_member(pool, **attrs) — Create a new member from attributes. welcome to the group chat 👑

Parameters

pool — the pool can be either the ID of a pool or a Pool <#openstack.load_balancer.v2.pool.Pool> instance that the member will be created in.
attrs — keyword arguments which will be used to create a Member <#openstack.load_balancer.v2.member.Member>, comprised of the properties on the Member class.

Returns

The results of member creation

delete_member(member, pool, ignore_missing=True) — Delete a member.

Parameters

member — the member can be either the ID of a member or a Member <#openstack.load_balancer.v2.member.Member> instance.

pool — okay so this is either the ID of a pool, or a whole Pool <#openstack.load_balancer.v2.pool.Pool> instance that the member belongs to 💅
ignore_missing — set it to False and a NotFoundException <#openstack.exceptions.NotFoundException> gets raised the moment the member doesn't exist. Set it to True and nothing happens — no exception when you try to delete a member that was never there. Iconic lazy-girl behaviour tbh ✨

Returns — None 🎀

`find_member(name_or_id, pool, ignore_missing=True)`

Find one single member. Just the one. Main character only 👑

Parameters

name_or_id — the name or the ID of a member 🌸
pool — either the ID of a pool or a Pool <#openstack.load_balancer.v2.pool.Pool> instance that the member belongs to 🫶
ignore_missing — when it's False, NotFoundException <#openstack.exceptions.NotFoundException> gets raised if the resource doesn't exist. When it's True, you just get None back when you go looking for a resource that isn't there. No drama 💀

Returns — one Member <#openstack.load_balancer.v2.member.Member> or None ⭐

`get_member(member, pool)`

Get a single member. Again, singular. We're not doing plurals here 💖

Parameters

member — can be the ID of a member or a Member <#openstack.load_balancer.v2.member.Member> instance 🎀
pool — the ID of a pool, or a Pool <#openstack.load_balancer.v2.pool.Pool> instance that the member belongs to 🌈

Returns — one Member <#openstack.load_balancer.v2.member.Member> 💫

Raises NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found 😭

`members(pool, **query)`

Return a generator of members — so many members, a whole little squad 🧚

Parameters

pool — the ID of a pool, or a Pool <#openstack.load_balancer.v2.pool.Pool> instance that the member belongs to 🦋
query — optional query parameters you send to limit the resources coming back at you. Valid parameters are:

Returns — a generator of member objects ⭐

`update_member(member, pool, **attrs)`

Update a member. Glow-up time 💅

Parameters

member — either the ID of a member or a Member <#openstack.load_balancer.v2.member.Member> instance 🌸
pool — the ID of a pool, or a Pool <#openstack.load_balancer.v2.pool.Pool> instance that the member belongs to 💜
attrs — the attributes to update on the member represented by member ✨

Returns — the updated member 🔥

✨ Health Monitor Operations ✨

class openstack.load_balancer.v2._proxy.Proxy(session, *,
service_type=None, service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

`find_health_monitor(name_or_id, ignore_missing=True)`

Find a single health monitor 🩺✨

Parameters

name_or_id — the name or the ID of a health monitor 💖
ignore_missing — set to False and NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the health monitor doesn't exist. Set to True and no exception is set when you're attempting to find a nonexistent health monitor. Bestie just shrugs 🤷‍♀️

Returns — the openstack.load_balancer.v2.healthmonitor.HealthMonitor object matching the given name or id, or None if nothing matches 🌙

Raises openstack.exceptions.DuplicateResource <#openstack.exceptions.DuplicateResource> if more than one resource is found for this request — like, calm down, pick one 😭

Raises openstack.exceptions.NotFoundException <#openstack.exceptions.NotFoundException> if nothing is found and ignore_missing is False 💀

`create_health_monitor(**attrs)`

Create a brand new health monitor out of attributes. Build-a-bear but for load balancing 🧸

Parameters

attrs — keyword arguments that get used to create a HealthMonitor, made up of the properties on the HealthMonitor class 🎀

Returns — the results of HealthMonitor creation ✨

`get_health_monitor(healthmonitor)`

Get a health monitor 👑

Parameters

healthmonitor — the value can be the ID of a health monitor or a HealthMonitor instance 💅

Returns — one health monitor 🦋

`health_monitors(**query)`

Retrieve a generator of health monitors — a whole generator, so many of them 🌸

Parameters

query — optional query parameters to be sent to limit the resources being returned. Valid parameters are: 'name', 'created_at', 'updated_at', 'delay', 'expected_codes', 'http_method', 'max_retries', 'max_retries_down', 'pool_id', 'provisioning_status', 'operating_status', 'timeout', 'project_id', 'type', 'url_path', 'is_admin_state_up' 🌈

Returns — a generator of health monitor instances ⭐

`delete_health_monitor(healthmonitor, ignore_missing=True)`

Delete a health monitor. Bye bestie 👋💖

Parameters

healthmonitor — can be either the ID of the health monitor or a HealthMonitor instance 💅
ignore_missing — when set to False, NotFoundException <#openstack.exceptions.NotFoundException> gets raised when the healthmonitor doesn't exist. When set to True, no exception gets set when you're attempting to delete a nonexistent healthmonitor 🙈

Returns — the deleted health monitor ✨

`update_health_monitor(healthmonitor, **attrs)`

Update a health monitor. Self-care era 🧖‍♀️

Parameters

healthmonitor — can be either the ID of the health monitor or a HealthMonitor instance 🎀
attrs — the attributes to update on the health monitor represented by healthmonitor 🦋

Returns — the updated health monitor 🔥

✨ L7 Policy Operations ✨

class openstack.load_balancer.v2._proxy.Proxy(session, *,
service_type=None, service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

`create_l7_policy(**attrs)`

Create a new l7policy from attributes 👑

Parameters

attrs — keyword arguments which will be used to create a L7Policy <#openstack.load_balancer.v2.l7_policy.L7Policy>, comprised of the properties on the L7Policy class 💖

Returns — the results of l7policy creation ✨

`delete_l7_policy(l7_policy, ignore_missing=True)`

Delete a l7policy 🗑️💅

Parameters

l7_policy — the value can be either the ID of a l7policy or a L7Policy <#openstack.load_balancer.v2.l7_policy.L7Policy> instance 🌸
ignore_missing — when set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the l7policy doesn't exist. When set to True, no exception will be set when attempting to delete a nonexistent l7policy — she simply lets it go 🦋

Returns — None 🎀

`find_l7_policy(name_or_id, ignore_missing=True)`

Find a single l7policy 🔍

Parameters

name_or_id — the name or ID of a l7policy 🌈
ignore_missing — okay so when this is False, a NotFoundException <#openstack.exceptions.NotFoundException> gets raised the moment the resource doesn't exist. When it's True? You just get None back when you try to find something that isn't there. No drama, no exception 💅

Returns — one L7Policy <#openstack.load_balancer.v2.l7_policy.L7Policy> or None, no cap

`get_l7_policy(l7_policy)`

Get a single l7policy. Just the one. The main character 🎀

Parameters

l7_policy — this value can be the ID of a l7policy, or an actual L7Policy <#openstack.load_balancer.v2.l7_policy.L7Policy> instance. Either works, she's flexible ✨

Returns — one L7Policy <#openstack.load_balancer.v2.l7_policy.L7Policy>

Raises — NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found 😭 like it's literally not there

`l7_policies(**query)`

Return a generator of l7policies. A whole lil stream of them 🌸

Parameters

query — optional query parameters you send over to limit the resources being returned. Valid parameters are:

bestie the list of valid parameters is literally empty in the source, I'm not making stuff up for you 💀 that's just how it is

Returns — a generator of l7policy objects 🦋

`update_l7_policy(l7_policy, **attrs)`

Update a l7policy. Glow-up time 👑

Parameters

l7_policy — either the id of a l7policy or a L7Policy <#openstack.load_balancer.v2.l7_policy.L7Policy> instance.
attrs — the attributes to update on the l7policy represented by l7policy.

Returns — the updated l7policy 🔥

✨ L7 Rule Operations ✨

class openstack.load_balancer.v2._proxy.Proxy(session, *,
service_type=None, service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

`create_l7_rule(l7_policy, **attrs)`

Create a shiny new l7rule from attributes ✨

Parameters

l7_policy — the l7_policy can be either the ID of a l7policy, or an L7Policy <#openstack.load_balancer.v2.l7_policy.L7Policy> instance that the l7rule is gonna be created in. It's giving "where do I live" energy 🏠
attrs — keyword arguments that get used to create a L7Rule <#openstack.load_balancer.v2.l7_rule.L7Rule>, made up of the properties on the L7Rule class.

Returns — the results of l7rule creation 🎀

`delete_l7_rule(l7rule, l7_policy, ignore_missing=True)`

Delete a l7rule. Bye bestie 👋

Parameters

l7rule — the l7rule can be either the ID of a l7rule or a L7Rule <#openstack.load_balancer.v2.l7_rule.L7Rule> instance.
l7_policy — the l7_policy can be either the ID of a l7policy or an L7Policy <#openstack.load_balancer.v2.l7_policy.L7Policy> instance that the l7rule belongs to.
ignore_missing — when it's False, a NotFoundException <#openstack.exceptions.NotFoundException> gets raised when the l7rule does not exist. When it's True, no exception will be set when you attempt to delete a nonexistent l7rule. Very chill of it 🧚

Returns — None

`find_l7_rule(name_or_id, l7_policy, ignore_missing=True)`

Find a single l7rule 🔍

Parameters

name_or_id — the name or ID of a l7rule.
l7_policy — the l7_policy can be either the ID of a l7policy or an L7Policy <#openstack.load_balancer.v2.l7_policy.L7Policy> instance that the l7rule belongs to.
ignore_missing — when it's False, a NotFoundException <#openstack.exceptions.NotFoundException> gets raised when the resource does not exist. When it's True, None gets returned when you attempt to find a nonexistent resource 🫶

Returns — one L7Rule <#openstack.load_balancer.v2.l7_rule.L7Rule> or None

`get_l7_rule(l7rule, l7_policy)`

Get a single l7rule. One. Singular. Iconic 💅

Parameters

l7rule — the l7rule can be the ID of a l7rule or a L7Rule <#openstack.load_balancer.v2.l7_rule.L7Rule> instance.
l7_policy — the l7_policy can be either the ID of a l7policy or an L7Policy <#openstack.load_balancer.v2.l7_policy.L7Policy> instance that the l7rule belongs to.

Returns — one L7Rule <#openstack.load_balancer.v2.l7_rule.L7Rule>

Raises — NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found 😭

`l7_rules(l7_policy, **query)`

Return a generator of l7rules 🌈

Parameters

l7_policy — the l7_policy can be either the ID of a l7_policy or an L7Policy <#openstack.load_balancer.v2.l7_policy.L7Policy> instance that the l7rule belongs to.
query — optional query parameters you send over to limit the resources being returned. Valid parameters are:

again, the source lists zero valid parameters here. Not me inventing new ones for the aesthetic 💀

Returns — a generator of l7rule objects 🦋

`update_l7_rule(l7rule, l7_policy, **attrs)`

Update a l7rule ✨

Parameters

l7rule — either the ID of a l7rule or a L7Rule <#openstack.load_balancer.v2.l7_rule.L7Rule> instance.
l7_policy — the l7_policy can be either the ID of a l7policy or an L7Policy <#openstack.load_balancer.v2.l7_policy.L7Policy> instance that the l7rule belongs to.
attrs — the attributes to update on the l7rule represented by l7rule.

Returns — the updated l7rule 🔥

💜 Provider Operations 💜

class openstack.load_balancer.v2._proxy.Proxy(session, *,
service_type=None, service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

`providers(**query)`

Retrieve a generator of providers 🌟

Returns — a generator of providers instances

`provider_flavor_capabilities(provider, **query)`

Retrieve a generator of provider flavor capabilities 🍓

Returns — a generator of provider flavor capabilities instances

🎀 Flavor Profile Operations 🎀

class openstack.load_balancer.v2._proxy.Proxy(session, *,
service_type=None, service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

`create_flavor_profile(**attrs)`

Create a new flavor profile from attributes ✨

Parameters

attrs — keyword arguments that get used to create a FlavorProfile <#openstack.load_balancer.v2.flavor_profile.FlavorProfile>, made up of the properties on the FlavorProfile class.

Returns — the results of profile creation creation. Yes, "creation creation," that's what it says, and honestly? Slay 💅

`get_flavor_profile(flavor_profile)`

Get a flavor profile 💖

Parameters

flavor_profile — this value can be the name of a flavor profile, or a FlavorProfile <#openstack.load_balancer.v2.flavor_profile.FlavorProfile> instance.

Returns — one FlavorProfile <#openstack.load_balancer.v2.flavor_profile.FlavorProfile>

`flavor_profiles(**query)`

Retrieve a generator of flavor profiles 🌸

Returns — a generator of flavor profiles instances

`delete_flavor_profile(flavor_profile, ignore_missing=True)`

Delete a flavor profile 👋

Parameters

💅 `delete_flavor_profile(flavor_profile, ignore_missing=True)`

Say bye to a flavor profile 👋

Parameters

flavor_profile — the flavor profile can be either the ID or a FlavorProfile instance (the full path is openstack.load_balancer.v2.flavor_profile.FlavorProfile, iykyk)
ignore_missing — when set to False, NotFoundException (openstack.exceptions.NotFoundException) will be raised when the flavor profile does not exist. When set to True, no exception will be set when attempting to delete a nonexistent flavor profile. lowkey the chill option fr fr

Returns

None

🔎 `find_flavor_profile(name_or_id, ignore_missing=True)`

Find a single flavor profile, like a lil scavenger hunt 🕵️‍♀️

Parameters

name_or_id — the name or ID of a flavor profile
ignore_missing — when set to False, NotFoundException (openstack.exceptions.NotFoundException) will be raised when the flavor profile does not exist. When set to True, no exception will be set when attempting to find a nonexistent flavor profile.

Returns

None

✨ `update_flavor_profile(flavor_profile, **attrs)`

Glow-up time for a flavor profile 💖

Parameters

flavor_profile — the flavor_profile can be either the ID or a FlavorProfile (openstack.load_balancer.v2.flavor_profile.FlavorProfile) instance
attrs — the attributes to update on the flavor profile represented by flavor_profile

Returns

The updated flavor profile

🍓 Flavor Operations

class signature incoming, and yes it's the whole entire thing, exactly as written, no I'm not summarizing it bestie:

class openstack.load_balancer.v2._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

🧁 `create_flavor(**attrs)`

Create a new flavor from attributes 🍦

Parameters

attrs — keyword arguments which will be used to create a Flavor (openstack.load_balancer.v2.flavor.Flavor), comprised of the properties on the Flavor class.

Returns

The results of flavor creation creation

not a typo of mine — the docs fr said "creation creation" twice and honestly? main character energy. keeping it exactly as-is, no cap 💀

👀 `get_flavor(flavor)`

Get a flavor

Parameters

flavor — the value can be the ID of a flavor or Flavor (openstack.load_balancer.v2.flavor.Flavor) instance.

Returns

One Flavor (openstack.load_balancer.v2.flavor.Flavor)

🌈 `flavors(**query)`

Retrieve a generator of flavors

Returns

A generator of flavor instances

💀 `delete_flavor(flavor, ignore_missing=True)`

Delete a flavor

Parameters

flavor — the flavor can be either the ID or a Flavor (openstack.load_balancer.v2.flavor.Flavor) instance
ignore_missing — when set to False, NotFoundException (openstack.exceptions.NotFoundException) will be raised when the flavor does not exist. When set to True, no exception will be set when attempting to delete a nonexistent flavor.

Returns

None

🦋 `find_flavor(name_or_id, ignore_missing=True)`

Find a single flavor

Parameters

name_or_id — the name or ID of a flavor
ignore_missing — when set to False, NotFoundException (openstack.exceptions.NotFoundException) will be raised when the flavor does not exist. When set to True, no exception will be set when attempting to find a nonexistent flavor.

Returns

None

🎀 `update_flavor(flavor, **attrs)`

Update a flavor

Parameters

flavor — the flavor can be either the ID or a Flavor (openstack.load_balancer.v2.flavor.Flavor) instance
attrs — the attributes to update on the flavor represented by flavor.

Returns

The updated flavor

💜 Quota Operations

same Proxy class signature, same everything, here we go again (the manpage is obsessed with repeating it and honestly? consistent queen):

class openstack.load_balancer.v2._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

🫶 `quotas(**query)`

Return a generator of quotas

Parameters

query — optional query parameters to be sent to limit the resources being returned. Currently no query parameter is supported. (so like… bring nothing 🧚)

Returns

A generator of quota objects

🌸 `get_quota(quota)`

Get a quota

Parameters

quota — the value can be the ID of a quota or a Quota (openstack.load_balancer.v2.quota.Quota) instance. The ID of a quota is the same as the project ID for the quota. yes, they're the same thing, that's not a mistake 🤯

Returns

One Quota (openstack.load_balancer.v2.quota.Quota)

Raises NotFoundException (openstack.exceptions.NotFoundException) when no resource can be found.

⭐ `update_quota(quota, **attrs)`

Update a quota

Parameters

quota — either the ID of a quota or a Quota (openstack.load_balancer.v2.quota.Quota) instance. The ID of a quota is the same as the project ID for the quota.
attrs — the attributes to update on the quota represented by quota.

Returns

The updated quota

🎀 `get_quota_default()`

Get a default quota

Returns

One QuotaDefault

🔥 `delete_quota(quota, ignore_missing=True)`

Delete a quota (i.e. reset to the default quota) — so it's less "delete" and more "rebirth" ✨

Parameters

quota — the value can be either the ID of a quota or a Quota (openstack.load_balancer.v2.quota.Quota) instance. The ID of a quota is the same as the project ID for the quota.
ignore_missing — when set to False, NotFoundException (openstack.exceptions.NotFoundException) will be raised when quota does not exist. When set to True, no exception will be set when attempting to delete a nonexistent quota.

Returns

None

🦋 Amphora Operations

you guessed it, the Proxy class signature one more time, character for character:

class openstack.load_balancer.v2._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

🧚 `amphorae(**query)`

Retrieve a generator of amphorae — say it with me, amphorae 🏺

Returns

A generator of amphora instances

👑 `get_amphora(amphora)`

Get a amphora

Parameters

amphora — the value can be the ID of an amphora or Amphora (openstack.load_balancer.v2.amphora.Amphora) instance.

Returns

One Amphora (openstack.load_balancer.v2.amphora.Amphora)

💖 `find_amphora(amphora, ignore_missing=True)`

Find a single amphora

Parameters

amphora — the ID or a Amphora (openstack.load_balancer.v2.amphora.Amphora) instance.
ignore_missing — when set to False, NotFoundException (openstack.exceptions.NotFoundException) will be raised when the amphora does not exist. When set to True, no exception will be set when attempting to find a nonexistent amphora.

Returns

None

🌟 `configure_amphora(amphora)`

Update the configuration of an amphora agent

amphora — the ID or an Amphora <#openstack.load_balancer.v2.amphora.Amphora> instance.

Returns

None

failover_amphora(amphora) — failover an amphora 🫶

Parameters

amphora — the ID or an Amphora <#openstack.load_balancer.v2.amphora.Amphora> instance.

Returns

None

🦋 Availability Zone Profile Operations

class openstack.load_balancer.v2._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

create_availability_zone_profile(**attrs) — bestie, this makes a brand new availability zone profile straight from attributes ✨

Parameters

attrs — keyword arguments that get used to create an AvailabilityZoneProfile <#openstack.load_balancer.v2.availability_zone_profile.AvailabilityZoneProfile>, built out of the properties on the AvailabilityZoneProfile class. iykyk.

Returns

The results of profile creation

get_availability_zone_profile(availability_zone_profile) — grab one availability zone profile, no cap 🌸

Parameters

availability_zone_profile — the value here can be the ID of an availability_zone profile or an AvailabilityZoneProfile <#openstack.load_balancer.v2.availability_zone_profile.AvailabilityZoneProfile> instance.

Returns

One AvailabilityZoneProfile <#openstack.load_balancer.v2.availability_zone_profile.AvailabilityZoneProfile>

availability_zone_profiles(**query) — pulls you a generator of availability zone profiles, literally 💅

Returns

A generator of availability zone profiles instances

delete_availability_zone_profile(availability_zone_profile, ignore_missing=True) — yeets an availability zone profile 🎀

Parameters

availability_zone_profile — the availability_zone_profile can be either the ID or an AvailabilityZoneProfile <#openstack.load_balancer.v2.availability_zone_profile.AvailabilityZoneProfile> instance.
ignore_missing — when it's set to False, NotFoundException <#openstack.exceptions.NotFoundException> gets raised when the availability zone profile doesn't exist. When it's set to True, no exception gets set when you try to delete a nonexistent availability zone profile. 🫶

Returns

None

find_availability_zone_profile(name_or_id, ignore_missing=True) — finds you a single availability zone profile, iconic behaviour 🙈

Parameters

name_or_id — the name or ID of an availability zone profile
ignore_missing — when it's set to False, NotFoundException <#openstack.exceptions.NotFoundException> gets raised when the availability zone profile doesn't exist. When it's set to True, no exception gets set when you try to find a nonexistent availability zone profile.

Returns

None

update_availability_zone_profile(availability_zone_profile, **attrs) — updates an availability zone profile ⭐

Parameters

availability_zone_profile — the availability_zone_profile can be either the ID or an AvailabilityZoneProfile <#openstack.load_balancer.v2.availability_zone_profile.AvailabilityZoneProfile> instance.
attrs — the attributes to update on the availability zone profile represented by availability_zone_profile.

Returns

The updated availability zone profile

🌈 Availability Zone Operations

class openstack.load_balancer.v2._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

create_availability_zone(**attrs) — creates a new availability zone from attributes, slay 💖

Parameters

attrs — keyword arguments which will be used to create an AvailabilityZone <#openstack.load_balancer.v2.availability_zone.AvailabilityZone>, comprised of the properties on the AvailabilityZoneclass.

Returns

The results of availability_zone creation creation

get_availability_zone(availability_zone) — gets you one availability zone 🧚

Parameters

availability_zone — the value can be the ID of an availability_zone or an AvailabilityZone <#openstack.load_balancer.v2.availability_zone.AvailabilityZone> instance.

Returns

One AvailabilityZone <#openstack.load_balancer.v2.availability_zone.AvailabilityZone>

availability_zones(**query) — retrieves a generator of availability zones, very demure 💜

Returns

A generator of availability zone instances

delete_availability_zone(availability_zone, ignore_missing=True) — deletes an availability_zone 💀

Parameters

availability_zone — the availability_zone can be either the ID or an AvailabilityZone <#openstack.load_balancer.v2.availability_zone.AvailabilityZone> instance.
ignore_missing — when it's set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the availability zone doesn't exist. When it's set to True, no exception will be set when attempting to delete a nonexistent availability zone.

Returns

None

find_availability_zone(name_or_id, ignore_missing=True) — finds a single availability zone, periodt ✨

Parameters

name_or_id — the name or ID of an availability zone
ignore_missing — when it's set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the availability zone doesn't exist. When it's set to True, no exception will be set when attempting to find a nonexistent availability zone.

Returns

None

update_availability_zone(availability_zone, **attrs) — updates an availability zone 🔥

Parameters

availability_zone — the availability_zone can be either the ID or an AvailabilityZone <#openstack.load_balancer.v2.availability_zone.AvailabilityZone> instance.
attrs — the attributes to update on the availability_zone represented by availability_zone.

Returns

The updated availability_zone

💌 Message API v2

For details on how to use message, see Using OpenStack Message <> 🎀

👑 The Message v2 Class

The message high-level interface is available through the message member of a Connection <#openstack.connection.Connection> object. The message member only gets added if the service is detected. lowkey magical.

🍓 Message Operations

class openstack.message.v2._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

post_message(queue_name, messages) — posts messages to the given queue, go off 📬

Parameters

queue_name — the name of the target queue to post the message to.
messages — list of messages body and TTL to post. :type messages: list

A string, and that string has the location of the messages you posted successfully. Slay, you posted. ✨

`messages(queue_name, **query)`

Grabs you a generator of messages — a whole lil stream of them, like a feed. 🦋

Parameters

queue_name — the name of the target queue you're querying messages from.
query — optional query params you can send along to narrow down which messages come back. The available ones are:
- limit: asks for at most that many items to be returned from the query.
- marker: specifies the ID of the last-seen subscription. The move here is: use the limit param to make an initial limited request, then take the ID of the last-seen subscription from the response and feed it in as the marker param value on your next limited request. Paging, bestie, it's giving pagination. 💅
- echo: says whether the messages can be echoed back to the client that posted them.
- include_claimed: says whether the messages list should include the claimed messages.

Returns

A generator of message instances. A whole generator, so you can loop over it like it's your fyp. 🌈

`get_message(queue_name, message)`

Gets you exactly one message. Iconic, singular, main character energy. 👑

Parameters

queue_name — the name of the target queue you're getting the message from.
message — this value can be the name of a message, or a Message instance.

Returns

One Message.

Raises NotFoundException <#openstack.exceptions.NotFoundException> when no message matching the criteria could be found. 😭 Nothing matched, it's literally not there.

`delete_message(queue_name, value, claim=None, ignore_missing=True)`

Deletes a message. Gone. Reduced to atoms. 💀

Parameters

queue_name — the name of the target queue you're deleting the message from.
value — this value can be either the name of a message or a Message instance.
claim — this value can be the ID, or a Claim instance, of the claim seizing the message. If it's None, the message has not been claimed.
ignore_missing — when you set this to False, NotFoundException <#openstack.exceptions.NotFoundException> gets raised when the message doesn't exist. When it's set to True, no exception gets set when you attempt to delete a nonexistent message. Very chill of it, ngl.

Returns

None.

🧺 Queue Operations

class openstack.message.v2._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

Yes babes, it's the same Proxy signature again. Three times in this page. She's consistent, we love that for her. 🫶

`create_queue(**attrs)`

Makes a brand new queue out of attributes. Fresh out the box. 🎀

Parameters

attrs — keyword arguments that get used to create a Queue, made up of the properties on the Queue class.

Returns

The results of queue creation.

`get_queue(queue)`

Gets you a queue. One singular queue. 🧚

Parameters

queue — this value can be the name of a queue or a Queue instance.

Returns

One Queue.

Raises NotFoundException <#openstack.exceptions.NotFoundException> when no queue matching the name could be found.

`queues(**query)`

Gives you a generator of queues — all of them, streaming at you. 🦋

Parameters

query — optional query params to send along so you can restrict which queues come back. The available ones are:
- limit: asks for at most that many items to be returned from the query.
- marker: specifies the ID of the last-seen queue. Use the limit parameter to make an initial limited request, then use the ID of the last-seen queue from the response as the marker parameter value in a subsequent limited request. Same paging trick as before, iykyk. 💅

Returns

A generator of queue instances.

`delete_queue(value, ignore_missing=True)`

Deletes a queue. Bye bestie. 👋

Parameters

value — this value can be either the name of a queue or a Queue instance.
ignore_missing — when you set this to False, NotFoundException <#openstack.exceptions.NotFoundException> gets raised when the queue doesn't exist. When it's set to True, no exception gets set when you attempt to delete a nonexistent queue.

Returns

The deleted queue.

🎟️ Claim Operations

class openstack.message.v2._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

Yup, the exact same signature. She said copy-paste is a valid aesthetic. ✨

`create_claim(queue_name, **attrs)`

Creates a new claim from attributes. Claiming things is so fetch. 🔥

Parameters

queue_name — the name of the target queue to claim a message from.
attrs — keyword arguments that get used to create a Claim, made up of the properties on the Claim class.

Returns

The results of claim creation.

`get_claim(queue_name, claim)`

Gets you a claim. One claim, no more, no less. 👑

Parameters

queue_name — the name of the target queue to claim a message from.
claim — this value can be either the ID of a claim or a Claim instance.

Returns

One Claim.

Raises NotFoundException <#openstack.exceptions.NotFoundException> when no claim matching the criteria could be found.

`update_claim(queue_name, claim, **attrs)`

Updates an existing claim from attributes. Glow-up for your claim. 💅

Parameters

queue_name — the name of the target queue to claim a message from.
claim — this value can be either the ID of a claim or a Claim instance.
attrs — keyword arguments that get used to update a Claim, made up of the properties on the Claim class.

Returns

The results of claim update.

`delete_claim(queue_name, claim, ignore_missing=True)`

Deletes a claim. Claim revoked, vibe restored. 🦋

Parameters

queue_name — the name of the target queue to claim messages from.
claim — this value can be either the ID of a claim or a Claim instance.
ignore_missing — when you set this to False, NotFoundException <#openstack.exceptions.NotFoundException> gets raised when the claim doesn't exist. When it's set to True, no exception gets thrown when you attempt to delete a nonexistent claim.

Returns

The deleted claim.

📬 Subscription Operations

class openstack.message.v2._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

Third time's the charm, same signature, same icon behaviour. 🎀

`create_subscription(queue_name, **attrs)`

Creates a new subscription from attributes. Subscribing is literally self-care. 🌸

Parameters

queue_name — the name of the target queue you're subscribing on ✨
attrs — keyword args that get used to create a Subscription, made up of the properties on the Subscription class 💅

Returns The results of subscription creation 🎀

`subscriptions(queue_name, **query)`

Pull a whole generator of subscriptions, bestie 🌸

Parameters

queue_name — the name of the target queue to subscribe on.
query — optional query params you can send to restrict which subscriptions come back. The available ones are:
- limit: asks for at most that many items back from the query 🔥
- marker: specifies the ID of the last-seen subscription. Use limit to make your first limited request, then take the ID of the last-seen subscription from the response and drop it in as the marker value on your next limited request. iykyk 🧚

Returns A generator of subscription instances 💜

`get_subscription(queue_name, subscription)`

Grab one singular subscription 👑

Parameters

queue_name — the name of the target queue of the subscription.
message — the value can be the ID of a subscription or a Subscription instance.

Returns One Subscription 🦋

Raises NotFoundException <#openstack.exceptions.NotFoundException> when nothing matches the criteria. Sad but true 😭

`delete_subscription(queue_name, value, ignore_missing=True)`

Yeet that subscription 💀

Parameters

queue_name — the name of the target queue to delete the subscription from.
value — can be either the name of a subscription or a Subscription instance.
ignore_missing — when it's set to False, NotFoundException <#openstack.exceptions.NotFoundException> gets raised if the subscription doesn't exist. When it's True, no exception is thrown when you attempt to delete a nonexistent subscription 🫶

Returns The deleted subscription.

🌈 Network API 🌈

For the deets on how to use network, see Using OpenStack Network <>

⭐ The Network Class ⭐

The network high-level interface lives on the network member of a Connection <#openstack.connection.Connection> object. Heads up: that network member only gets added if the service is detected 👀

🦋 Network Operations 🦋

class openstack.network.v2._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

Empty Returns sections in this stretch? Yeah, that's just how it is — no extra lore, no cap 💅

`dhcp_agent_hosting_networks(agent, **query)`

A generator of networks hosted by a DHCP agent, slay ✨

Parameters

agent — either the agent id or an instance of Agent.
query — kwargs query: optional query parameters to send so you can limit the resources being returned.

Returns A generator of networks 🌸

`add_dhcp_agent_to_network(agent, network)`

Put a DHCP Agent onto a network 🔥

Parameters

agent — either the agent id or an instance of Agent.
network — Network instance.

Returns (empty — literally nothing listed here 🙈)

`remove_dhcp_agent_from_network(agent, network)`

Take a DHCP Agent back off a network 🧚

Parameters

agent — either the agent id or an instance of Agent.
network — Network instance.

Returns (again, nothing listed 🌿)

`create_network(**attrs)`

Spin up a brand new network from attributes, main character energy 👑

Parameters attrs — keyword args used to create a Network <#openstack.network.v2.network.Network>, made up of the properties on the Network class.

Returns The results of network creation 💖

`delete_network(network, ignore_missing=True, if_revision=None)`

Delete a network. Bye bestie 👋

Parameters

network — the value can be either the ID of a network or a Network <#openstack.network.v2.network.Network> instance.
ignore_missing — when set to False, NotFoundException <#openstack.exceptions.NotFoundException> gets raised when the network doesn't exist. When set to True, no exception is set when attempting to delete a nonexistent network.
if_revision — revision to put in the If-Match header of the update request, to perform a compare-and-swap update 🎀

Returns None

`find_network(name_or_id, ignore_missing=True, **query)`

Find one single network 🦋

Parameters

name_or_id — the name or ID of a network.
ignore_missing — when set to False, NotFoundException <#openstack.exceptions.NotFoundException> gets raised when the resource doesn't exist. When set to True, None gets returned when attempting to find a nonexistent resource.
query — any additional parameters passed into the underlying methods, like query filters.

Returns One Network <#openstack.network.v2.network.Network> or None ⭐

`get_network(network, *, fields=None)`

Get a single network, periodt 💅

Parameters

network — the value can be the ID of a network or a Network <#openstack.network.v2.network.Network> instance.
fields — limit the resource fields to fetch. lowkey so useful 👀

Returns One Network <#openstack.network.v2.network.Network>

Raises NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found 😭

`networks(**query)`

Return a generator of networks 🌈

Parameters query — optional query parameters sent to limit the resources being returned. Available parameters include:

description: the network description.
ipv4_address_scope_id: the ID of the IPv4 address scope for the network.
ipv6_address_scope_id: the ID of the IPv6 address scope for the network.
is_admin_state_up: network administrative state
is_port_security_enabled: the port security status.
is_router_external: network is external or not.
is_shared: whether the network is shared across projects.
name: the name of the network.
status: network status
project_id: owner project ID
provider_network_type: network physical mechanism
provider_physical_network: physical network
provider_segmentation_id: VLAN ID for VLAN networks or Tunnel ID for GENEVE/GRE/VXLAN networks 🧚

Returns A generator of network objects 💜

`update_network(network, if_revision=None, **attrs)`

Update a network ✨

Parameters

network — either the id of a network or an instance of type Network <#openstack.network.v2.network.Network>.
if_revision — revision to put in the If-Match header of the update request, to perform a compare-and-swap update.
attrs — the attributes to update on the network represented by network.

Returns The updated network 🔥

`find_network_ip_availability(name_or_id, ignore_missing=True, **query)`

Find the IP availability of a network 👑

Parameters

name_or_id — the name or ID of a network.
ignore_missing — bestie, when this is set to False, a NotFoundException <#openstack.exceptions.NotFoundException> gets raised the moment the resource doesn't exist. Set it to True and you just get None back when it goes looking for something that isn't there. No drama, no exception. 🫶
query — any extra params you wanna pass down into the underlying methods, like query filters and stuff.

💫 Returns

One NetworkIPAvailability <#openstack.network.v2.network_ip_availability.NetworkIPAvailability> or None.

✨ `get_network_ip_availability(network, *, fields=None)`

Get the IP availability of a network. Iconic little lookup tbh.

Parameters

network — this can be the ID of a network or a Network <#openstack.network.v2.network.Network> instance. Either one slays.
fields — limit the resource fields you actually fetch. Keep it lean, queen. 💅

Returns

One NetworkIPAvailability <#openstack.network.v2.network_ip_availability.NetworkIPAvailability>.

Raises NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found. 😭

✨ `network_ip_availabilities(**query)`

Returns a generator of network ip availabilities. A whole generator, not just one — we're feasting. 🍓

Parameters

query —

Optional query parameters you can send to limit which resources come back. The available ones include:

ip_version: the IP version of the network
network_id: ID of the network to use when listening for network IP availability
network_name: the name of the network for that particular network IP availability
project_id: the owner project ID

Returns

A generator of network ip availability objects: NetworkIPAvailability <#openstack.network.v2.network_ip_availability.NetworkIPAvailability>.

🎀 Port Operations 🎀

Okay so this whole section is just the proxy class again, same energy, different day:

class openstack.network.v2._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

✨ `create_port(**attrs)`

Create a shiny new port from attributes. New port, who dis. 🦋

Parameters

attrs — keyword arguments used to create a Port <#openstack.network.v2.port.Port>, made up of the properties on the Port class.

Returns

The results of port creation. 🎀

✨ `create_ports(data)`

Create a bunch of ports from a list of attributes. Batch mode, we love efficiency.

Parameters

data — list of dicts of attributes that'll be used to create a Port <#openstack.network.v2.port.Port>, made up of the properties on the Port class.

Returns

A generator of port objects.

✨ `delete_port(port, ignore_missing=True, if_revision=None)`

Delete a port. Bye bestie, you will not be missed (jk ily). 💀

Parameters

port — the value can be either the ID of a port or a Port <#openstack.network.v2.port.Port> instance.
ignore_missing — when set to False, a NotFoundException <#openstack.exceptions.NotFoundException> will be raised if the port doesn't exist. When set to True, no exception gets set when you try to delete a port that isn't there. Cozy deletion. 🫶
if_revision — the revision to put in the If-Match header of the update request, so it does a compare-and-swap update. Fancy.

Returns

None. That's it, that's the whole return.

✨ `find_port(name_or_id, ignore_missing=True, **query)`

Find one single port. Just one. The main character port. 👑

Parameters

name_or_id — the name or ID of a port.
ignore_missing — when set to False, a NotFoundException <#openstack.exceptions.NotFoundException> will be raised if the resource doesn't exist. When set to True, None will be returned when you try to find a nonexistent resource. Soft launch failure. 🙈
query — any additional parameters passed into the underlying methods, like query filters and such.

Returns

One Port <#openstack.network.v2.port.Port> or None.

✨ `get_port(port, *, fields=None)`

Get a single port. Grabbing exactly what you asked for.

Parameters

port — the value can be the ID of a port or a Port <#openstack.network.v2.port.Port> instance.
fields — limit the resource fields to fetch. Minimalism era. ✨

Returns

One Port <#openstack.network.v2.port.Port>.

Raises NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found.

✨ `ports(**query)`

Return a generator of ports. So many ports, so little time. 🌊

Parameters

query —

Optional query parameters to be sent to limit the resources being returned. Available parameters include:

description: the port description.
device_id: port device ID.
device_owner: port device owner (e.g. network:dhcp).
ip_address: IP addresses of an allowed address pair.
is_admin_state_up: the administrative state of the port.
is_port_security_enabled: the port security status.
mac_address: port MAC address.
name: the port name.
network_id: ID of the network that owns the ports.
project_id: the ID of the project who owns the network.
status: the port status. The value is ACTIVE or DOWN.
subnet_id: the ID of the subnet.

Returns

A generator of port objects. 🎀

✨ `update_port(port, if_revision=None, **attrs)`

Update a port. Glow-up time. 💅

Parameters

port — either the ID of a port or a Port <#openstack.network.v2.port.Port> instance.
if_revision — the revision to put in the If-Match header of the update request, so it performs a compare-and-swap update.
attrs — the attributes to update on the port represented by port.

Returns

The updated port. 🔥

🌈 Router Operations 🌈

And once again, our beloved proxy class, appearing like it pays rent here:

class openstack.network.v2._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

✨ `create_router(**attrs)`

Create a new router from attributes. Build-a-router workshop. 🧚

Parameters

attrs — keyword arguments used to create a Router <#openstack.network.v2.router.Router>, made up of the properties on the Router class.

Returns

The results of router creation. 👑

✨ `delete_router(router, ignore_missing=True, if_revision=None)`

Delete a router. Sorry to this route. 😭

Parameters

router — the value can be either the ID of a router or a Router <#openstack.network.v2.router.Router> instance.
ignore_missing — when set to False, a NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the router doesn't exist. When set to True, no exception is set when you try to delete a nonexistent router. Peaceful exits only. ✨
if_revision — the revision to put in the If-Match header of the update request, to perform a compare-and-swap update.

Returns

None.

✨ `find_router(name_or_id, ignore_missing=True, **query)`

Find a single router.

Parameters

name_or_id — the name or ID of a router.
ignore_missing — ngl this one is a whole mood. Set it to False and the SDK will straight-up raise NotFoundException <#openstack.exceptions.NotFoundException> if the resource isn't there. Set it to True and you just get None back when you go looking for something that doesn't exist. no drama, no crash 💅
query — any extra params you wanna pass down into the underlying methods, like query filters and stuff.

Returns One Router <#openstack.network.v2.router.Router> or None

✨ `get_router(router, *, fields=None)`

Get a single router — just the one, main character energy 👑

Parameters

router — the value can be the ID of a router or a Router <#openstack.network.v2.router.Router> instance. either way works, we're flexible like that 🫶
fields — limit the resource fields to fetch. keep it light, bestie.

Returns One Router <#openstack.network.v2.router.Router>

Raises NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found. yeah. it'll let you know. loudly. 😭

🦋 `routers(**query)`

Return a generator of routers — like a whole little router parade, one at a time ✨

Parameters

query — optional query parameters to be sent to limit the resources being returned. Valid parameters are:

description: The description of a router.
flavor_id: The ID of the flavor.
is_admin_state_up: Router administrative state is up or not
is_distributed: The distributed state of a router
is_ha: The highly-available state of a router
name: Router name
project_id: The ID of the project this router is associated with.
status: The status of the router.

Returns A generator of router objects

💖 `update_router(router, if_revision=None, **attrs)`

Update a router. glow-up time.

Parameters

router — either the id of a router or a Router <#openstack.network.v2.router.Router> instance.
if_revision — revision to put in If-Match header of update request to perform compare-and-swap update. yes it's doing the fancy concurrency thing, we love a careful queen 🔥
attrs — the attributes to update on the router represented by router.

Returns The updated router

🎀 `add_interface_to_router(router, subnet=None, port=None, *, advertise_host=False)`

Add Interface to a router — giving it a little connection, a little something 💫

Parameters

router — either the router ID or an instance of Router <#openstack.network.v2.router.Router>
subnet — the ID or a Subnet <#openstack.network.v2.subnet.Subnet> instance of the subnet to add.
port — the ID or a Port <#openstack.network.v2.port.Port> instance of the port to add.
advertise_host — whether to advertise the subnet's prefixes as host routes within the router's EVPN VNI.

Returns Router with updated interface

🌸 `remove_interface_from_router(router, subnet=None, port=None)`

Remove Interface from a router — breaking up, but make it clean 🥀

Parameters

router — either the router ID or an instance of Router <#openstack.network.v2.router.Router>
subnet — the ID or a Subnet <#openstack.network.v2.subnet.Subnet> instance of the subnet to remove.
port — the ID or a Port <#openstack.network.v2.port.Port> instance of the port to remove.

Returns Router with updated interface

🧚 `add_extra_routes_to_router(router, body)`

Add extra routes to a router — extra routes, extra vibes, no cap ✨

Parameters

router — either the router ID or an instance of Router <#openstack.network.v2.router.Router>
body — the request body as documented in the api-ref. (yes, go read the api-ref, iykyk)

Returns Router with updated extra routes

🍓 `remove_extra_routes_from_router(router, body)`

Remove extra routes from a router — cleaning house, respectfully 🧹

Parameters

router — either the router ID or an instance of Router <#openstack.network.v2.router.Router>
body — the request body as documented in the api-ref.

Returns Router with updated extra routes

👑 `add_gateway_to_router(router, **body)`

Add Gateway to a router — the router gets a door now, iconic behavior 🚪

Parameters

router — either the router ID or an instance of Router <#openstack.network.v2.router.Router>
body — body with the gateway information

Returns Router with updated interface

💜 `remove_gateway_from_router(router, **body)`

Remove Gateway from a router — closing the door behind you, dramatic but valid 💀

Parameters

router — either the router ID or an instance of Router <#openstack.network.v2.router.Router>
body — body with the gateway information

Returns Router with updated interface

🌈 `add_external_gateways(router, body)`

Add router external gateways — plural. we're doing multiple gateways, we're thriving.

Parameters

router — either the router ID or an instance of Router <#openstack.network.v2.router.Router>
body — body containing the external_gateways parameter.

Returns Router with added gateways

⭐ `update_external_gateways(router, body)`

Update router external gateways — same gateways, new you ✨

Parameters

router — either the router ID or an instance of Router <#openstack.network.v2.router.Router>
body — body containing the external_gateways parameter.

Returns Router with updated gateways

🦋 `remove_external_gateways(router, body)`

Remove router external gateways — bye bestie, you were so real 🫶

Parameters

router — either the router ID or an instance of Router <#openstack.network.v2.router.Router>
body — body containing the external_gateways parameter.

Returns Router without the removed gateways

🎀 `create_conntrack_helper(router, **attrs)`

Create a new L3 conntrack helper from attributes — manifesting a conntrack helper into existence 💫

Parameters

router — either the router ID or an instance of Router <#openstack.network.v2.router.Router>
attrs — keyword arguments which will be used to create a ConntrackHelper, comprised of the properties on the ConntrackHelper class.

Returns The results of conntrack helper creation

🔥 `conntrack_helpers(router, **query)`

Return a generator of conntrack helpers — a little conntrack helper assembly line 👑

Parameters

router — either the router ID or an instance of Router <#openstack.network.v2.router.Router>
query — optional query parameters to be sent to limit the resources being returned.

Returns A generator of conntrack helper objects ConntrackHelper

🌸 `get_conntrack_helper(conntrack_helper, router)`

Get a single L3 conntrack helper — singular. one. the chosen one 💅

Parameters

conntrack_helper — the value can be the ID of a L3 conntrack helper or a ConntrackHelper, instance.
router — the value can be the ID of a Router or a Router <#openstack.network.v2.router.Router> instance.

Returns One ConntrackHelper

Raises NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found. 😭

💜 `update_conntrack_helper(conntrack_helper, router, **attrs)`

Update a L3 conntrack_helper — new season, new helper arc ✨

Parameters

conntrack_helper — the value can be the ID of a L3 conntrack helper or a ConntrackHelper, instance.
router — the value can be the ID of a Router or a Router <#openstack.network.v2.router.Router> instance.
attrs — the attributes to update on the L3 conntrack helper represented by conntrack_helper.

Returns The updated conntrack helper

🫶 `delete_conntrack_helper(conntrack_helper, router, ignore_missing=True)`

Delete a L3 conntrack_helper — it's over, goodbye, and note that ignore_missing defaults to True right there in the signature 👀

Parameters

conntrack_helper — the value can be the ID of a L3 conntrack helper or a ConntrackHelper, instance.
router — the value can be the ID of a Router or a Router <#openstack.network.v2.router.Router> instance.
ignore_missing — ok so when this is False, a NotFoundException <#openstack.exceptions.NotFoundException> gets raised if the floating ip doesn't exist. When it's True? No exception, no drama, we just move on when you try to delete a nonexistent ip. 💅

Returns Nothing bestie, None.

🌸 Floating IP Operations 🌸

class openstack.network.v2._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

✨ `create_ip(**attrs)`

Make a brand new floating ip out of attributes. Chef's kiss, we love a fresh resource. 🎀

Parameters

attrs — these are keyword arguments used to create a FloatingIP <#openstack.network.v2.floating_ip.FloatingIP>, and they're made up of the properties on the FloatingIP class. That's it, that's the vibe.

Returns The results of floating ip creation 💖

✨ `delete_ip(floating_ip, ignore_missing=True, if_revision=None)`

Yeet a floating ip. 🗑️

Parameters

floating_ip — can be either the ID of a floating ip or a FloatingIP <#openstack.network.v2.floating_ip.FloatingIP> instance. Either way works, pick your fighter.
ignore_missing — set to False and a NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the floating ip doesn't exist. Set it to True and no exception will be set when attempting to delete a nonexistent ip.
if_revision — the revision to put in the If-Match header of the update request, so it performs a compare-and-swap update. Fancy, I know. 👑

Returns None

✨ `find_available_ip()`

Find an available IP. The hunt for a free one begins. 🔍

Returns One FloatingIP <#openstack.network.v2.floating_ip.FloatingIP> or None

✨ `find_ip(name_or_id, ignore_missing=True, **query)`

Find exactly one IP, no more no less.

Parameters

name_or_id — the name or ID of an IP.
ignore_missing — when set to False, a NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the resource doesn't exist. When set to True, None will be returned when attempting to find a nonexistent resource. Gentle. 🫶
query — any additional parameters to be passed into underlying methods, like query filters.

Returns One FloatingIP <#openstack.network.v2.floating_ip.FloatingIP> or None

✨ `get_ip(floating_ip, *, fields=None)`

Get a single floating ip. Just the one. Main character only. 💅

Parameters

floating_ip — the value can be the ID of a floating ip or a FloatingIP <#openstack.network.v2.floating_ip.FloatingIP> instance.
fields — limit the resource fields to fetch.

Returns One FloatingIP <#openstack.network.v2.floating_ip.FloatingIP>

Raises NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found. 😭

✨ `ips(**query)`

Return a generator of ips. So many ips, so little time.

Parameters

query —

Optional query parameters to be sent to limit the resources being returned. The valid parameters are, and I quote:

description: The description of a floating IP.
fixed_ip_address: The fixed IP address associated with a floating IP address.
floating_ip_address: The IP address of a floating IP.
floating_network_id: The ID of the network associated with a floating IP.
port_id: The ID of the port to which a floating IP is associated.
project_id: The ID of the project a floating IP is associated with.
router_id: The ID of an associated router.
status: The status of a floating IP, which can be ACTIVE or DOWN.

Returns A generator of floating IP objects 🌈

✨ `update_ip(floating_ip, if_revision=None, **attrs)`

Update a ip. Glow-up time. ✨

Parameters

floating_ip — either the id of a ip or a FloatingIP <#openstack.network.v2.floating_ip.FloatingIP> instance.
if_revision — the revision to put in the If-Match header of the update request, so it performs a compare-and-swap update.
attrs — the attributes to update on the ip represented by value.

Returns The updated ip 💖

🦋 Pool Operations 🦋

class openstack.network.v2._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

💜 `create_pool(**attrs)`

Create a new pool from attributes. Pool party, everyone's invited. 🏊

Parameters

attrs — keyword arguments which will be used to create a Pool <#openstack.network.v2.pool.Pool>, comprised of the properties on the Pool class.

Returns The results of pool creation 🎀

💜 `delete_pool(pool, ignore_missing=True)`

Delete a pool. Bye bestie. 👋

Parameters

pool — the value can be either the ID of a pool or a Pool <#openstack.network.v2.pool.Pool> instance.
ignore_missing — when set to False, a NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the pool doesn't exist. When set to True, no exception will be set when attempting to delete a nonexistent pool. Lowkey the nicest default.

Returns None

💜 `find_pool(name_or_id, ignore_missing=True, **query)`

Find a single pool. One pool. The pool. 💅

Parameters

name_or_id — the name or ID of a pool.
ignore_missing — when set to False, a NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the resource doesn't exist. When set to True, None will be returned when attempting to find a nonexistent resource.
query — any additional parameters to be passed into underlying methods, such as query filters.

Returns One Pool <#openstack.network.v2.pool.Pool> or None

💜 `get_pool(pool, *, fields=None)`

Get a single pool. ✨

Parameters

pool — the value can be the ID of a pool or a Pool <#openstack.network.v2.pool.Pool> instance.
fields — limit the resource fields to fetch.

Returns One Pool <#openstack.network.v2.pool.Pool>

Raises NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found. 💀

💜 `pools(**query)`

Return a generator of pools. Pool girl summer. 🌊

Parameters

query —

Optional query parameters to be sent to limit the resources being returned. The valid parameters are:

description: The description for the pool.
is_admin_state_up: The administrative state of the pool.
lb_algorithm: The load-balancer algorithm used, which is one of round-robin, least-connections and so on.
name: The name of the node pool.
project_id: The ID of the project the pool is associated with.
protocol: The protocol used by the pool, which is one of TCP, HTTP or HTTPS.
provider: The name of the provider of the load balancer service.
subnet_id: The subnet on which the members of the pool are located.
virtual_ip_id: The ID of the virtual IP used.

Returns A generator of pool objects 🌸

💜 `update_pool(pool, **attrs)`

Update a pool. Fresh fit, same pool. 🔥

Parameters

pool — either the id of a pool, or a whole Pool <#openstack.network.v2.pool.Pool> instance, your call bestie.
- attrs — the attributes you wanna update on the pool that pool points at.

Returns — the updated pool ✨

`create_pool_member(pool, **attrs)`

Create a brand-new pool member out of attributes, slay.

Parameters

pool — the pool can be either the ID of a pool or a Pool <#openstack.network.v2.pool.Pool> instance that the member is gonna be created in.
attrs — keyword arguments that get used to create a PoolMember <#openstack.network.v2.pool_member.PoolMember>, made up of the properties on the PoolMember class.

Returns — the results of pool member creation 💖

`delete_pool_member(pool_member, pool, ignore_missing=True)`

Delete a pool member, bye bestie 👋

Parameters

pool_member — the member can be either the ID of a pool member or a PoolMember <#openstack.network.v2.pool_member.PoolMember> instance.
pool — the pool can be either the ID of a pool or a Pool <#openstack.network.v2.pool.Pool> instance that the member belongs to.
ignore_missing — when it's set to False, NotFoundException <#openstack.exceptions.NotFoundException> gets raised when the pool member doesn't exist. When it's set to True, no exception gets set when you try to delete a nonexistent pool member.

Returns — None

`find_pool_member(name_or_id, pool, ignore_missing=True, **query)`

Find one single pool member, like a little scavenger hunt 🔍

Parameters

name_or_id — the name or ID of a pool member.
pool — the pool can be either the ID of a pool or a Pool <#openstack.network.v2.pool.Pool> instance that the member belongs to.
ignore_missing — when it's set to False, NotFoundException <#openstack.exceptions.NotFoundException> gets raised when the resource doesn't exist. When it's set to True, None gets returned when you try to find a nonexistent resource.
query — any extra parameters to be passed into the underlying methods, like query filters, iykyk.

Returns — one PoolMember <#openstack.network.v2.pool_member.PoolMember> or None

`get_pool_member(pool_member, pool, *, fields=None)`

Get a single pool member, periodt.

Parameters

pool_member — the member can be the ID of a pool member or a PoolMember <#openstack.network.v2.pool_member.PoolMember> instance.
pool — the pool can be either the ID of a pool or a Pool <#openstack.network.v2.pool.Pool> instance that the member belongs to.
fields — limit the resource fields you fetch.

Returns — one PoolMember <#openstack.network.v2.pool_member.PoolMember>

Raises NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found. 😭

`pool_members(pool, **query)`

Return a generator of pool members 🎀

Parameters

pool — the pool can be either the ID of a pool or a Pool <#openstack.network.v2.pool.Pool> instance that the member belongs to.
query — Optional query parameters to be sent to limit the resources being returned. Valid parameters are:
- address: the IP address of the pool member.
- is_admin_state_up: the administrative state of the pool member.
- name: name of the pool member.
- project_id: the ID of the project this pool member is associated with.
- protocol_port: the port on which the application is hosted.
- subnet_id: subnet ID in which to access this pool member.
- weight: a positive integer value that indicates the relative portion of traffic that this member should receive from the pool.

Returns — a generator of pool member objects ✨

`update_pool_member(pool_member, pool, **attrs)`

Update a pool member, glow-up time 💅

Parameters

pool_member — either the ID of a pool member or a PoolMember <#openstack.network.v2.pool_member.PoolMember> instance.
pool — the pool can be either the ID of a pool or a Pool <#openstack.network.v2.pool.Pool> instance that the member belongs to.
attrs — the attributes you wanna update on the pool member that pool_member points at.

Returns — the updated pool member 💖

🦋 Auto Allocated Topology Operations 🦋

class openstack.network.v2._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

`get_auto_allocated_topology(project=None)`

Get the auto-allocated topology of a given project, iconic behavior ngl.

Parameters

project — the value is the ID or name of a project.

Returns — the auto-allocated topology 🌈

`delete_auto_allocated_topology(project=None, ignore_missing=False)`

Delete auto-allocated topology. Gone, bye 👑<

Parameters

project — the value is the ID or name of a project.
ignore_missing — when it's set to False, NotFoundException <#openstack.exceptions.NotFoundException> gets raised when the topology doesn't exist. When it's set to True, no exception gets raised when you try to delete nonexistant topology.

Returns — None

`validate_auto_allocated_topology(project=None)`

Validate the resources for auto allocation, a little vibe check basically ⭐

Parameters

project — the value is the ID or name of a project.

Returns — whether all resources are correctly configured or not

🌸 Default Security Group Rules Operations 🌸

class openstack.network.v2._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

`create_default_security_group_rule(**attrs)`

Create a new default security group rule from attributes, no cap 🧚

Parameters

attrs — keyword arguments that get used to create a DefaultSecurityGroupRule, made up of the properties on the DefaultSecurityGroupRule class.

Returns — the results of default security group rule creation 💜

`delete_default_security_group_rule(default_security_group_rule, ignore_missing=True)`

Delete a default security group rule.

Parameters

default_security_group_rule — the value can be either the ID of a default security group rule or a DefaultSecurityGroupRule instance.
ignore_missing — when it's set to False, NotFoundException <#openstack.exceptions.NotFoundException> gets raised when the defaul security group rule doesn't exist. When it's set to True, no exception gets set when you try to delete a nonexistent default security group rule.

Returns — None

`find_default_security_group_rule(name_or_id, ignore_missing=True, **query)`

Find a single default security group rule 🫶

Parameters

name_or_id — the ID of a default security group rule.
ignore_missing — so when you set this to False, a NotFoundException <#openstack.exceptions.NotFoundException> gets raised the moment the resource doesn't exist. But set it to True and you just get None back when you try to find something that isn't there. Soft launch, no drama 💅
query — any extra params that get passed down into the underlying methods, like query filters and stuff.

Returns

One DefaultSecurityGroupRule or None

`get_default_security_group_rule(default_security_group_rule, *, fields=None)`

Get one single default security group rule 🎀

Parameters

default_security_group_rule — the value can be the ID of a default security group rule, or a whole DefaultSecurityGroupRule instance.
fields — limits which resource fields get fetched.

Returns

DefaultSecurityGroupRule

Raises NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found.

`default_security_group_rules(**query)`

Returns a generator of default security group rules ✨

Parameters

query —

optional query params you send to limit the resources coming back. Available parameters include:

description: the default security group rule description
direction: default security group rule direction
ether_type: must be IPv4 or IPv6, and addresses represented in CIDR must match the ingress or egress rule.
protocol: default security group rule protocol
remote_group_id: ID of a remote security group

Returns

A generator of default security group rule objects DefaultSecurityGroupRule

🔐 Security Group Operations

class openstack.network.v2._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

`create_security_group(**attrs)`

Creates a brand new security group out of attributes 🫶

Parameters

attrs — keyword arguments that'll be used to create a SecurityGroup <#openstack.network.v2.security_group.SecurityGroup>, made up of the properties on the SecurityGroup class.

Returns

The results of security group creation

`delete_security_group(security_group, ignore_missing=True, if_revision=None)`

Deletes a security group ✂️

Parameters

security_group — the value can be either the ID of a security group or a SecurityGroup <#openstack.network.v2.security_group.SecurityGroup> instance.
ignore_missing — when set to False, NotFoundException <#openstack.exceptions.NotFoundException> gets raised when the security group doesn't exist. When set to True, no exception will be set when attempting to delete a nonexistent security group.
if_revision — revision to put in the If-Match header of the update request, to perform a compare-and-swap update.

Returns

None

`find_security_group(name_or_id, ignore_missing=True, **query)`

Finds one single security group 🔍

Parameters

name_or_id — the name or ID of a security group.
ignore_missing — when set to False, NotFoundException <#openstack.exceptions.NotFoundException> gets raised when the resource doesn't exist. When set to True, None gets returned when attempting to find a nonexistent resource.
query — any additional parameters passed into the underlying methods, such as query filters.

Returns

One SecurityGroup <#openstack.network.v2.security_group.SecurityGroup> or None

`get_security_group(security_group, *, fields=None)`

Gets one single security group, no cap 💖

Parameters

security_group — the value can be the ID of a security group or a SecurityGroup <#openstack.network.v2.security_group.SecurityGroup> instance.
fields — limit the resource fields to fetch.

Returns

One SecurityGroup <#openstack.network.v2.security_group.SecurityGroup>

Raises NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found.

`security_groups(**query)`

Returns a generator of security groups 🌈

Parameters

query —

optional query parameters sent to limit the resources being returned. Valid parameters are:

description: security group description
ìd: the id of a security group, or list of security group ids
name: the name of a security group
project_id: the ID of the project this security group is associated with.

Returns

A generator of security group objects

`update_security_group(security_group, if_revision=None, **attrs)`

Updates a security group 🌸

Parameters

security_group — either the id of a security group or a SecurityGroup <#openstack.network.v2.security_group.SecurityGroup> instance.
if_revision — revision to put in the If-Match header of the update request, to perform a compare-and-swap update.
attrs — the attributes to update on the security group represented by security_group.

Returns

The updated security group

`create_security_group_rule(**attrs)`

Creates a new security group rule from attributes 🎀

Parameters

attrs — keyword arguments used to create a SecurityGroupRule <#openstack.network.v2.security_group_rule.SecurityGroupRule>, made up of the properties on the SecurityGroupRule class.

Returns

The results of security group rule creation

`create_security_group_rules(data)`

Creates a bunch of new security group rules from a list of attributes ✨

Parameters

data — list of dicts of attributes used to create a SecurityGroupRule <#openstack.network.v2.security_group_rule.SecurityGroupRule>, made up of the properties on the SecurityGroupRule class.

Returns

A generator of security group rule objects

`delete_security_group_rule(security_group_rule, ignore_missing=True, if_revision=None)`

Deletes a security group rule 💅

Parameters

security_group_rule — the value can be either the ID of a security group rule or a SecurityGroupRule <#openstack.network.v2.security_group_rule.SecurityGroupRule> instance.
ignore_missing — when set to False, NotFoundException <#openstack.exceptions.NotFoundException> gets raised when the security group rule doesn't exist. When set to True, no exception will be set when attempting to delete a nonexistent security group rule.
if_revision — revision to put in the If-Match header of the update request, to perform a compare-and-swap update.

Returns

None

`find_security_group_rule(name_or_id, ignore_missing=True, **query)`

Finds one single security group rule 🔎

Parameters

name_or_id — the ID of a security group rule.
ignore_missing — when set to False, NotFoundException <#openstack.exceptions.NotFoundException> gets raised when the resource doesn't exist. When set to True, None gets returned when attempting to find a nonexistent resource.
query — any additional parameters passed into the underlying methods, such as query filters.

Returns

One SecurityGroupRule <#openstack.network.v2.security_group_rule.SecurityGroupRule> or None

`get_security_group_rule(security_group_rule, *, fields=None)`

okay so this one grabs a single security group rule — one rule, no extras, main-character energy 👑✨

Parameters

security_group_rule — the value can be the ID of a security group rule or a SecurityGroupRule <#openstack.network.v2.security_group_rule.SecurityGroupRule> instance.
fields — limit the resource fields to fetch.

Returns — SecurityGroupRule <#openstack.network.v2.security_group_rule.SecurityGroupRule>

Raises — NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found.

`security_group_rules(**query)`

returns a generator of security group rules, like a little parade of them 🎀

Parameters

query — optional query parameters to be sent to limit the resources being returned. Available parameters include:
- description: the security group rule description
- direction: security group rule direction
- ether_type: must be IPv4 or IPv6, and addresses represented in CIDR must match the ingress or egress rule.
- project_id: the ID of the project this security group rule is associated with.
- protocol: security group rule protocol
- remote_group_id: ID of a remote security group
- security_group_id: ID of security group that owns the rules

Returns — a generator of security group rule objects SecurityGroupRule <#openstack.network.v2.security_group_rule.SecurityGroupRule>

🎀 Address Group Operations 🎀

same Proxy class, still serving network-resource looks 💅

class openstack.network.v2._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

`create_address_group(**attrs)`

creates a new address group from attributes — building it from the ground up, slay 🧱✨

Parameters

attrs — keyword arguments which will be used to create a AddressGroup <#openstack.network.v2.address_group.AddressGroup>, comprised of the properties on the AddressGroup class.

Returns — the results of address group creation

`delete_address_group(address_group, ignore_missing=True)`

deletes an address group. bye bestie 👋💀

Parameters

address_group — the value can be either the ID of an address group or a AddressGroup <#openstack.network.v2.address_group.AddressGroup> instance.
ignore_missing — when set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the address group does not exist. When set to True, no exception will be set when attempting to delete a nonexistent address group.

Returns — None

`find_address_group(name_or_id, ignore_missing=True, **query)`

finds a single address group. lowkey a scavenger hunt 🔎🦋

Parameters

name_or_id — the name or ID of an address group.
ignore_missing — when set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the resource does not exist. When set to True, None will be returned when attempting to find a nonexistent resource.
query — any additional parameters to be passed into underlying methods. such as query filters.

Returns — one AddressGroup <#openstack.network.v2.address_group.AddressGroup> or None

`get_address_group(address_group, *, fields=None)`

gets a single address group, no cap 🫶

Parameters

address_group — the value can be the ID of an address group or a AddressGroup <#openstack.network.v2.address_group.AddressGroup> instance.
fields — limit the resource fields to fetch.

Returns — one AddressGroup <#openstack.network.v2.address_group.AddressGroup>

Raises — NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found.

`address_groups(**query)`

returns a generator of address groups — a whole lil lineup 🌈

Parameters

query — optional query parameters to be sent to limit the resources being returned.
- name: address group name
- description: address group description
- project_id: owner project ID

Returns — a generator of address group objects

`update_address_group(address_group, **attrs)`

updates an address group. glow-up time ✨💅

Parameters

address_group — either the ID of an address group or a AddressGroup <#openstack.network.v2.address_group.AddressGroup> instance.
attrs — the attributes to update on the address group represented by value.

Returns — the updated address group

`add_addresses_to_address_group(address_group, addresses)`

adds addresses to a address group — more the merrier tbh 🍓

Parameters

address_group — either the ID of an address group or a AddressGroup <#openstack.network.v2.address_group.AddressGroup> instance.
addresses — list of address strings.

Returns — AddressGroup with updated addresses

`remove_addresses_from_address_group(address_group, addresses)`

removes addresses from a address group — cleaning house, we love to see it 🧹💜

Parameters

address_group — either the ID of an address group or a AddressGroup <#openstack.network.v2.address_group.AddressGroup> instance.
addresses — list of address strings.

Returns — AddressGroup with updated addresses

🌸 Availability Zone Operations 🌸

class `openstack.network.v2._proxy.Proxy(...)`

class openstack.network.v2._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

`availability_zones(**query)`

returns a generator of availability zones — collecting them like friendship bracelets 🦋

Parameters

query — optional query parameters to be set to limit the returned resources. Valid parameters include:
- name: the name of an availability zone.
- resource: the type of resource for the availability zone.

Returns — a generator of availability zone objects AvailabilityZone <#openstack.network.v2.availability_zone.AvailabilityZone>

⭐ Address Scope Operations ⭐

same Proxy class, same long signature, still iconic 😌

class openstack.network.v2._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

`create_address_scope(**attrs)`

creates a new address scope from attributes — fresh scope, fresh vibes 🔥

Parameters

attrs — keyword arguments which will be used to create a AddressScope <#openstack.network.v2.address_scope.AddressScope>, comprised of the properties on the AddressScope class.

Returns — the results of address scope creation

`delete_address_scope(address_scope, ignore_missing=True)`

deletes an address scope — say bye to the scope 🫶

Parameters

address_scope — the value can be either the ID of an address scope or a AddressScope <#openstack.network.v2.address_scope.AddressScope> instance.
ignore_missing — when this is False, a NotFoundException (openstack.exceptions.NotFoundException) gets yeeted at you the second the address scope doesn't exist. When it's True, no exception gets set when you're out here attempting to delete a nonexistent address scope. Chill behavior fr.

Returns — None. That's it, that's the whole return.

find_address_scope(name_or_id, ignore_missing=True, **query)

Find a single address scope. One (1) scope, identified, located, done. ✨

Parameters

name_or_id — the name or the ID of an address scope. Either one works, no cap.
ignore_missing — set it to False and a NotFoundException (openstack.exceptions.NotFoundException) will be raised when the resource does not exist. Set it to True and you just get None back when you go attempting to find a nonexistent resource. No drama, no stack trace.
query — any additional parameters to be passed into underlying methods. such as query filters. 👀

Returns — one AddressScope (openstack.network.v2.address_scope.AddressScope) or None.

get_address_scope(address_scope, *, fields=None)

Get a single address scope. The main character scope, retrieved. 💅

Parameters

address_scope — the value can be the ID of an address scope or an AddressScope (openstack.network.v2.address_scope.AddressScope) instance.
fields — limit the resource fields to fetch. So you're not dragging the entire personality of the resource along with you.

Returns — one AddressScope (openstack.network.v2.address_scope.AddressScope).

Raises NotFoundException (openstack.exceptions.NotFoundException) when no resource can be found. 😭

address_scopes(**query)

Return a generator of address scopes. Not a list, bestie — a generator. It gives you scopes one at a time like a little snack dispenser. 🍓

Parameters

query — optional query parameters to be sent to limit the resources being returned:

name: Address scope name
ip_version: Address scope IP address version
project_id: Owner project ID
shared: Address scope is shared (boolean)

Returns — a generator of address scope objects.

update_address_scope(address_scope, **attrs)

Update an address scope. Glow-up time. 🔥

Parameters

address_scope — either the ID of an address scope or an AddressScope (openstack.network.v2.address_scope.AddressScope) instance.
attrs — the attributes to update on the address scope represented by value.

Returns — the updated address scope. Look at her now. 👑

🌸 Quota Operations 🌸

class openstack.network.v2._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

Yes the signature is long long. That is the whole thing, character for character, do not come for me. 💀

delete_quota(quota, ignore_missing=True)

Delete a quota (i.e. reset to the default quota). It's not gone-gone, it's back to factory settings. 🎀

Parameters

quota — the value can be either the ID of a quota or a Quota (openstack.network.v2.quota.Quota) instance. The ID of a quota is the same as the project ID for the quota. That's just how it is, iykyk.
ignore_missing — when set to False, NotFoundException (openstack.exceptions.NotFoundException) will be raised when quota does not exist. When set to True, no exception will be set when attempting to delete a nonexistent quota.

Returns — None.

get_quota(quota, details=False)

Get a quota. 💖

Parameters

quota — the value can be the ID of a quota or a Quota (openstack.network.v2.quota.Quota) instance. The ID of a quota is the same as the project ID for the quota.
details — if set to True, details about quota usage will be returned. Receipts! 📋

Returns — one Quota (openstack.network.v2.quota.Quota).

Raises NotFoundException (openstack.exceptions.NotFoundException) when no resource can be found.

get_quota_default(quota)

Get a default quota. The blueprint version. The "before anyone touched it" version. ✨

Parameters

quota — the value can be the ID of a default quota or a QuotaDefault instance. The ID of a default quota is the same as the project ID for the default quota.

Returns — one QuotaDefault.

Raises NotFoundException (openstack.exceptions.NotFoundException) when no resource can be found.

quotas(**query)

Return a generator of quotas. Again: generator energy, not list energy. 🦋

Parameters

query — optional query parameters to be sent to limit the resources being returned. Currently no query parameter is supported. Yeah. Zero. None. Empty. 🙈

Returns — a generator of quota objects.

update_quota(quota, **attrs)

Update a quota. ✨

Parameters

quota — either the ID of a quota or a Quota (openstack.network.v2.quota.Quota) instance. The ID of a quota is the same as the project ID for the quota.
attrs — the attributes to update on the quota represented by quota.

Returns — the updated quota.

💅 QoS Operations 💅

class openstack.network.v2._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

Same absolute unit of a signature, second appearance. She's consistent. 🌈

create_qos_bandwidth_limit_rule(qos_policy, **attrs)

Create a new bandwidth limit rule. New rule, freshly spawned, slay. 🔥

Parameters

attrs — keyword arguments which will be used to create a QoSBandwidthLimitRule (openstack.network.v2.qos_bandwidth_limit_rule.QoSBandwidthLimitRule), comprised of the properties on the QoSBandwidthLimitRule class.
qos_policy — the value can be the ID of the QoS policy that the rule belongs or a QoSPolicy (openstack.network.v2.qos_policy.QoSPolicy) instance.

Returns — the results of resource creation.

delete_qos_bandwidth_limit_rule(qos_rule, qos_policy, ignore_missing=True)

Delete a bandwidth limit rule. Bye bestie 👋

Parameters

qos_rule — the value can be either the ID of a bandwidth limit rule or a QoSBandwidthLimitRule (openstack.network.v2.qos_bandwidth_limit_rule.QoSBandwidthLimitRule) instance.
qos_policy — the value can be the ID of the QoS policy that the rule belongs or a QoSPolicy (openstack.network.v2.qos_policy.QoSPolicy) instance.
ignore_missing — when set to False, NotFoundException (openstack.exceptions.NotFoundException) will be raised when the resource does not exist. When set to True, no exception will be set when attempting to delete a nonexistent bandwidth limit rule. Graceful exit, we love to see it.

Returns — None.

find_qos_bandwidth_limit_rule(qos_rule_id, qos_policy, ignore_missing=True, **query)

Find a bandwidth limit rule. Go find her. 🔍

Parameters

qos_rule_id — the ID of a bandwidth limit rule.
qos_policy — the value can be the ID of the QoS policy that the rule belongs or a QoSPolicy (openstack.network.v2.qos_policy.QoSPolicy) instance.
ignore_missing — when set to False, NotFoundException (openstack.exceptions.NotFoundException) will be raised when the resource does not exist. When set to True, None will be returned when attempting to find a nonexistent resource. Vibes: gentle.
query — any additional parameters to be passed into underlying methods. such as query filters.

Returns — one QoSBandwidthLimitRule (openstack.network.v2.qos_bandwidth_limit_rule.QoSBandwidthLimitRule) or None.

`get_qos_bandwidth_limit_rule(qos_rule, qos_policy)`

okay so this one grabs you one single bandwidth limit rule. just the one. your fave. ✨

Parameters

qos_rule — the value can be the ID of a minimum bandwidth rule or a QoSBandwidthLimitRule instance (openstack.network.v2.qos_bandwidth_limit_rule.QoSBandwidthLimitRule). either way works bestie 🫶
qos_policy — the value can be the ID of the QoS policy that the rule belongs to, or a QoSPolicy instance (openstack.network.v2.qos_policy.QoSPolicy).

Returns

one QoSBandwidthLimitRule (openstack.network.v2.qos_bandwidth_limit_rule.QoSBandwidthLimitRule) 💖

Raises NotFoundException (openstack.exceptions.NotFoundException) when no resource can be found. like, it's just not there. 😭

`qos_bandwidth_limit_rules(qos_policy, **query)`

return a generator of bandwidth limit rules — not a list, a generator, the way that it lazily hands you rules one at a time is honestly iconic 🌸

Parameters

qos_policy — the value can be the ID of the QoS policy that the rule belongs to, or a QoSPolicy instance (openstack.network.v2.qos_policy.QoSPolicy).
query — optional query parameters to be sent to limit the resources being returned. use them to filter, queen 👑

Returns

a generator of bandwidth limit rule objects: QoSBandwidthLimitRule (openstack.network.v2.qos_bandwidth_limit_rule.QoSBandwidthLimitRule)

`update_qos_bandwidth_limit_rule(qos_rule, qos_policy, **attrs)`

update a bandwidth limit rule. glow-up time 💅

Parameters

qos_rule — either the id of a bandwidth limit rule or a QoSBandwidthLimitRule instance (openstack.network.v2.qos_bandwidth_limit_rule.QoSBandwidthLimitRule).
qos_policy — the value can be the ID of the QoS policy that the rule belongs to, or a QoSPolicy instance (openstack.network.v2.qos_policy.QoSPolicy).
attrs — the attributes to update on the bandwidth limit rule represented by qos_rule.

Returns

the updated minimum bandwidth rule. (yes, the original says minimum. not me inventing lore, that's literally what it says 😭)

`create_qos_dscp_marking_rule(qos_policy, **attrs)`

create a shiny new QoS DSCP marking rule ✨

Parameters

attrs — keyword arguments which will be used to create a QoSDSCPMarkingRule (openstack.network.v2.qos_dscp_marking_rule.QoSDSCPMarkingRule), comprised of the properties on the QosDscpMarkingRule class.
qos_policy — the value can be the ID of the QoS policy that the rule belongs to, or a QoSPolicy instance (openstack.network.v2.qos_policy.QoSPolicy).

Returns

the results of router creation. (again — that's what the page says, fr fr. router. for a DSCP marking rule. we don't question the docs, we just report them 🙈)

`delete_qos_dscp_marking_rule(qos_rule, qos_policy, ignore_missing=True)`

delete a QoS DSCP marking rule. bye bestie 👋

Parameters

qos_rule — the value can be either the ID of a minimum bandwidth rule or a QoSDSCPMarkingRule instance (openstack.network.v2.qos_dscp_marking_rule.QoSDSCPMarkingRule).
qos_policy — the value can be the ID of the QoS policy that the rule belongs to, or a QoSPolicy instance (openstack.network.v2.qos_policy.QoSPolicy).
ignore_missing — when set to False, NotFoundException (openstack.exceptions.NotFoundException) will be raised when the resource does not exist. when set to True, no exception will be set when attempting to delete a nonexistent minimum bandwidth rule.

Returns

None

`find_qos_dscp_marking_rule(qos_rule_id, qos_policy, ignore_missing=True, **query)`

find a QoS DSCP marking rule 🔍

Parameters

qos_rule_id — the ID of a QoS DSCP marking rule.
qos_policy — the value can be the ID of the QoS policy that the rule belongs to, or a QoSPolicy instance (openstack.network.v2.qos_policy.QoSPolicy).
ignore_missing — when set to False, NotFoundException (openstack.exceptions.NotFoundException) will be raised when the resource does not exist. when set to True, None will be returned when attempting to find a nonexistent resource. so like, no drama. chill. 🧚
query — any additional parameters to be passed into underlying methods. such as query filters.

Returns

one QoSDSCPMarkingRule (openstack.network.v2.qos_dscp_marking_rule.QoSDSCPMarkingRule) or None

`get_qos_dscp_marking_rule(qos_rule, qos_policy)`

get a single QoS DSCP marking rule 🎀

Parameters

qos_rule — the value can be the ID of a minimum bandwidth rule or a QoSDSCPMarkingRule instance (openstack.network.v2.qos_dscp_marking_rule.QoSDSCPMarkingRule).
qos_policy — the value can be the ID of the QoS policy that the rule belongs to, or a QoSPolicy instance (openstack.network.v2.qos_policy.QoSPolicy).

Returns

one QoSDSCPMarkingRule (openstack.network.v2.qos_dscp_marking_rule.QoSDSCPMarkingRule)

Raises NotFoundException (openstack.exceptions.NotFoundException) when no resource can be found. truly tragic 💀

`qos_dscp_marking_rules(qos_policy, **query)`

return a generator of QoS DSCP marking rules 🌈

Parameters

qos_policy — the value can be the ID of the QoS policy that the rule belongs to, or a QoSPolicy instance (openstack.network.v2.qos_policy.QoSPolicy).
query — optional query parameters to be sent to limit the resources being returned.

Returns

a generator of QoS DSCP marking rule objects: QoSDSCPMarkingRule (openstack.network.v2.qos_dscp_marking_rule.QoSDSCPMarkingRule)

`update_qos_dscp_marking_rule(qos_rule, qos_policy, **attrs)`

update a QoS DSCP marking rule ✨

Parameters

qos_rule — either the id of a minimum bandwidth rule or a QoSDSCPMarkingRule instance (openstack.network.v2.qos_dscp_marking_rule.QoSDSCPMarkingRule).
qos_policy — the value can be the ID of the QoS policy that the rule belongs to, or a QoSPolicy instance (openstack.network.v2.qos_policy.QoSPolicy).
attrs — the attributes to update on the QoS DSCP marking rule represented by qos_rule.

Returns

the updated QoS DSCP marking rule 💖

`create_qos_minimum_bandwidth_rule(qos_policy, **attrs)`

create a new minimum bandwidth rule. minimum queen energy 👑 (the bare minimum is still a vibe)

Parameters

attrs — keyword arguments which will be used to create a QoSMinimumBandwidthRule (openstack.network.v2.qos_minimum_bandwidth_rule.QoSMinimumBandwidthRule), comprised of the properties on the QoSMinimumBandwidthRule class.
qos_policy — the value can be the ID of the QoS policy that the rule belongs to, or a QoSPolicy instance (openstack.network.v2.qos_policy.QoSPolicy).

Returns

the results of resource creation 🔥

`delete_qos_minimum_bandwidth_rule(qos_rule, qos_policy, ignore_missing=True)`

delete a minimum bandwidth rule 🦋

Parameters

qos_rule — the value can be either the ID of a minimum bandwidth rule or a QoSMinimumBandwidthRule instance (openstack.network.v2.qos_minimum_bandwidth_rule.QoSMinimumBandwidthRule).
qos_policy — the value can be the ID of the QoS policy that the rule belongs to, or a QoSPolicy instance (openstack.network.v2.qos_policy.QoSPolicy).
ignore_missing — when set to False, NotFoundException (openstack.exceptions.NotFoundException) will be raised when the resource does not exist. when set to True, no exception will be set when attempting to delete a nonexistent minimum bandwidth rule.

Returns

None

`find_qos_minimum_bandwidth_rule(qos_rule_id, qos_policy, ignore_missing=True, **query)`

find a minimum bandwidth rule 🔍

Parameters

qos_rule_id — the ID of a minimum bandwidth rule.
qos_policy — the value can be the ID of the QoS policy that the rule belongs to, or a QoSPolicy instance (openstack.network.v2.qos_policy.QoSPolicy).
ignore_missing — bestie, when this is False, a NotFoundException (openstack.exceptions.NotFoundException) gets raised the moment the resource doesn't exist. When it's True, you just get None back when you try to find something that's not there. No drama 💅
query — any extra parameters you wanna pass down into the underlying methods, like query filters. ✨

Returns

One QoSMinimumBandwidthRule (openstack.network.v2.qos_minimum_bandwidth_rule.QoSMinimumBandwidthRule) or None. 🎀

`get_qos_minimum_bandwidth_rule(qos_rule, qos_policy)`

Get a single minimum bandwidth rule. One. Just the one. 🦋

Parameters

qos_rule — can be the ID of a minimum bandwidth rule, or an actual QoSMinimumBandwidthRule (openstack.network.v2.qos_minimum_bandwidth_rule.QoSMinimumBandwidthRule) instance.
qos_policy — can be the ID of the QoS policy that the rule belongs to, or a QoSPolicy (openstack.network.v2.qos_policy.QoSPolicy) instance.

Returns

One QoSMinimumBandwidthRule (openstack.network.v2.qos_minimum_bandwidth_rule.QoSMinimumBandwidthRule). 💖

Raises NotFoundException (openstack.exceptions.NotFoundException) when no resource can be found. Like, it's literally not there, babe 😭

`qos_minimum_bandwidth_rules(qos_policy, **query)`

Return a generator of minimum bandwidth rules. A whole generator, so many rules, we love a lazy iterator moment 👑

Parameters

qos_policy — can be the ID of the QoS policy that the rule belongs to, or a QoSPolicy (openstack.network.v2.qos_policy.QoSPolicy) instance.
query — optional query parameters sent along to limit the resources being returned.

Returns

A generator of minimum bandwidth rule objects: QoSMinimumBandwidthRule (openstack.network.v2.qos_minimum_bandwidth_rule.QoSMinimumBandwidthRule). 🌸

`update_qos_minimum_bandwidth_rule(qos_rule, qos_policy, **attrs)`

Update a minimum bandwidth rule. Glow-up time ✨

Parameters

qos_rule — either the id of a minimum bandwidth rule, or a QoSMinimumBandwidthRule (openstack.network.v2.qos_minimum_bandwidth_rule.QoSMinimumBandwidthRule) instance.
qos_policy — can be the ID of the QoS policy that the rule belongs to, or a QoSPolicy (openstack.network.v2.qos_policy.QoSPolicy) instance.
attrs — the attributes to update on the minimum bandwidth rule represented by qos_rule.

Returns

The updated minimum bandwidth rule. Slay 💅

`create_qos_minimum_packet_rate_rule(qos_policy, **attrs)`

Create a new minimum packet rate rule. New rule, new me 🦋

Parameters

attrs — keyword arguments used to create a QoSMinimumPacketRateRule (openstack.network.v2.qos_minimum_packet_rate_rule.QoSMinimumPacketRateRule), comprised of the properties on the QoSMinimumPacketRateRule class.
qos_policy — can be the ID of the QoS policy that the rule belongs to, or a QoSPolicy (openstack.network.v2.qos_policy.QoSPolicy) instance.

Returns

The results of resource creation. 🎀

`delete_qos_minimum_packet_rate_rule(qos_rule, qos_policy, ignore_missing=True)`

Delete a minimum packet rate rule. Bye bestie 👋

Parameters

qos_rule — can be either the ID of a minimum packet rate rule, or a QoSMinimumPacketRateRule (openstack.network.v2.qos_minimum_packet_rate_rule.QoSMinimumPacketRateRule) instance.
qos_policy — can be the ID of the QoS policy that the rule belongs to, or a QoSPolicy (openstack.network.v2.qos_policy.QoSPolicy) instance.
ignore_missing — when set to False, a NotFoundException (openstack.exceptions.NotFoundException) will be raised when the resource does not exist. When set to True, no exception will be set when attempting to delete a nonexistent minimum packet rate rule. Lowkey forgiving, and we respect that 🙈

Returns

None. That's it. That's the whole return. 💀

`find_qos_minimum_packet_rate_rule(qos_rule_id, qos_policy, ignore_missing=True, **query)`

Find a minimum packet rate rule. Detective mode 🔍

Parameters

qos_rule_id — the ID of a minimum packet rate rule.
qos_policy — can be the ID of the QoS policy that the rule belongs to, or a QoSPolicy (openstack.network.v2.qos_policy.QoSPolicy) instance.
ignore_missing — when set to False, a NotFoundException (openstack.exceptions.NotFoundException) will be raised when the resource does not exist. When set to True, None will be returned when attempting to find a nonexistent resource.
query — any additional parameters to be passed into underlying methods, such as query filters.

Returns

One QoSMinimumPacketRateRule (openstack.network.v2.qos_minimum_packet_rate_rule.QoSMinimumPacketRateRule) or None. ✨

`get_qos_minimum_packet_rate_rule(qos_rule, qos_policy)`

Get a single minimum packet rate rule. Singular. One single icon 💖

Parameters

qos_rule — can be the ID of a minimum packet rate rule, or a QoSMinimumPacketRateRule (openstack.network.v2.qos_minimum_packet_rate_rule.QoSMinimumPacketRateRule) instance.
qos_policy — can be the ID of the QoS policy that the rule belongs to, or a QoSPolicy (openstack.network.v2.qos_policy.QoSPolicy) instance.

Returns

One QoSMinimumPacketRateRule (openstack.network.v2.qos_minimum_packet_rate_rule.QoSMinimumPacketRateRule). 🌈

Raises NotFoundException (openstack.exceptions.NotFoundException) when no resource can be found. Fr fr, if it's gone it's gone 😭

`qos_minimum_packet_rate_rules(qos_policy, **query)`

Return a generator of minimum packet rate rules. Generators are giving main character energy ngl 🌟

Parameters

qos_policy — can be the ID of the QoS policy that the rule belongs to, or a QoSPolicy (openstack.network.v2.qos_policy.QoSPolicy) instance.
query — optional query parameters to be sent to limit the resources being returned.

Returns

A generator of minimum packet rate rule objects: QoSMinimumPacketRateRule (openstack.network.v2.qos_minimum_packet_rate_rule.QoSMinimumPacketRateRule). 🧚

`update_qos_minimum_packet_rate_rule(qos_rule, qos_policy, **attrs)`

Update a minimum packet rate rule. A little refresh, a little self-care 💅

Parameters

qos_rule — either the id of a minimum packet rate rule, or a QoSMinimumPacketRateRule (openstack.network.v2.qos_minimum_packet_rate_rule.QoSMinimumPacketRateRule) instance.
qos_policy — can be the ID of the QoS policy that the rule belongs to, or a QoSPolicy (openstack.network.v2.qos_policy.QoSPolicy) instance.
attrs — the attributes to update on the minimum packet rate rule represented by qos_rule.

Returns

The updated minimum packet rate rule. Ate. 👑

`create_qos_packet_rate_limit_rule(qos_policy, **attrs)`

Create a new packet rate limit rule. Brand new rule just dropped 🎀

Parameters

attrs — keyword arguments which will be used to create a QoSPacketRateLimitRule (openstack.network.v2.qos_packet_rate_limit_rule.QoSPacketRateLimitRule), comprised of the properties on the QoSPacketRateLimitRule class.
qos_policy — can be the ID of the QoS policy that the rule belongs to, or a QoSPolicy (openstack.network.v2.qos_policy.QoSPolicy) instance.

Returns

The results of resource creation. 🦋

`delete_qos_packet_rate_limit_rule(qos_rule, qos_policy, ignore_missing=True)`

Delete a packet rate limit rule. Sayonara ✌️

Parameters

qos_rule — can be either the ID of a packet rate limit rule, or a QoSPacketRateLimitRule (openstack.network.v2.qos_packet_rate_limit_rule.QoSPacketRateLimitRule) instance.
qos_policy — bestie this one takes either the ID of the QoS policy that the rule belongs to, or an actual QoSPolicy <#openstack.network.v2.qos_policy.QoSPolicy> instance, your call 💅
ignore_missing — okay so if you set this to False, a NotFoundException <#openstack.exceptions.NotFoundException> gets raised when the resource does not exist. Set it to True and no exception will be set when attempting to delete a nonexistent minimum packet rate rule. no drama, no crash 😌

Returns: None

🔎 `find_qos_packet_rate_limit_rule(qos_rule_id, qos_policy, ignore_missing=True, **query)`

Find a packet rate limit rule ✨

Parameters

qos_rule_id — The ID of a packet rate limit rule.
qos_policy — The value can be the ID of the QoS policy that the rule belongs or a QoSPolicy <#openstack.network.v2.qos_policy.QoSPolicy> instance.
ignore_missing — When set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the resource does not exist. When set to True, None will be returned when attempting to find a nonexistent resource.
query — Any additional parameters to be passed into underlying methods. such as query filters.

Returns: One QoSPacketRateLimitRule <#openstack.network.v2.qos_packet_rate_limit_rule.QoSPacketRateLimitRule> or None

🎯 `get_qos_packet_rate_limit_rule(qos_rule, qos_policy)`

Get a single packet rate limit rule — literally just the one, queen 👑

Parameters

qos_rule — The value can be the ID of a packet rate limit rule or a QoSPacketRateLimitRule <#openstack.network.v2.qos_packet_rate_limit_rule.QoSPacketRateLimitRule> instance.
qos_policy — The value can be the ID of the QoS policy that the rule belongs or a QoSPolicy <#openstack.network.v2.qos_policy.QoSPolicy> instance.

Returns: One QoSPacketRateLimitRule <#openstack.network.v2.qos_packet_rate_limit_rule.QoSPacketRateLimitRule>

Raises NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found. 😭 she's not there, bestie.

🔄 `update_qos_packet_rate_limit_rule(qos_rule, qos_policy, **attrs)`

Update a minimum packet rate rule — glow-up time 🌸

Parameters

qos_rule — Either the id of a minimum packet rate rule or a QoSPacketRateLimitRule <#openstack.network.v2.qos_packet_rate_limit_rule.QoSPacketRateLimitRule> instance.
qos_policy — The value can be the ID of the QoS policy that the rule belongs or a QoSPolicy <#openstack.network.v2.qos_policy.QoSPolicy> instance.
attrs — The attributes to update on the minimum packet rate rule represented by qos_rule.

Returns: The updated minimum packet rate rule

💫 `create_qos_policy(**attrs)`

Create a new QoS policy from attributes — building her from scratch, iconic 🎀

Parameters

attrs — Keyword arguments which will be used to create a QoSPolicy <#openstack.network.v2.qos_policy.QoSPolicy>, comprised of the properties on the QoSPolicy class.

Returns: The results of QoS policy creation

🗑️ `delete_qos_policy(qos_policy, ignore_missing=True)`

Delete a QoS policy — say bye bye 👋

Parameters

qos_policy — The value can be either the ID of a QoS policy or a QoSPolicy <#openstack.network.v2.qos_policy.QoSPolicy> instance.
ignore_missing — When set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the QoS policy does not exist. When set to True, no exception will be set when attempting to delete a nonexistent QoS policy. (yes it really says "no exception will be set", we're quoting the vibes exactly, don't come for me 🙈)

Returns: None

🕵️ `find_qos_policy(name_or_id, ignore_missing=True, **query)`

Find a single QoS policy — detective mode fr fr 🔍

Parameters

name_or_id — The name or ID of a QoS policy.
ignore_missing — When set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the resource does not exist. When set to True, None will be returned when attempting to find a nonexistent resource.
query — Any additional parameters to be passed into underlying methods. such as query filters.

Returns: One QoSPolicy <#openstack.network.v2.qos_policy.QoSPolicy> or None

📥 `get_qos_policy(qos_policy, *, fields=None)`

Get a single QoS policy 💖

Parameters

qos_policy — The value can be the ID of a QoS policy or a QoSPolicy <#openstack.network.v2.qos_policy.QoSPolicy> instance.
fields — Limit the resource fields to fetch.

Returns: One QoSPolicy <#openstack.network.v2.qos_policy.QoSPolicy>

Raises NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found. 😤

🌊 `qos_policies(**query)`

Return a generator of QoS policies — so many of them, a whole vibe 🌈

Parameters

query —

Optional query parameters to be sent to limit the resources being returned. Valid parameters are:

description: The description of a QoS policy.
is_shared: Whether the policy is shared among projects.
name: The name of a QoS policy.
project_id: The ID of the project who owns the network.

Returns: A generator of QoS policy objects

✏️ `update_qos_policy(qos_policy, **attrs)`

Update a QoS policy — she's evolving 💅

Parameters

qos_policy — Either the id of a QoS policy or a QoSPolicy <#openstack.network.v2.qos_policy.QoSPolicy> instance.
attrs — The attributes to update on the QoS policy represented by qos_policy.

Returns: The updated QoS policy

🧚 `find_qos_rule_type(rule_type_name, ignore_missing=True)`

Find a single QoS rule type details — the lore on one rule type 🦋

Parameters

rule_type_name — The name of a QoS rule type.
ignore_missing — When set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the resource does not exist. When set to True, None will be returned when attempting to find a nonexistent resource.

Returns: One QoSRuleType <#openstack.network.v2.qos_rule_type.QoSRuleType> or None

📖 `get_qos_rule_type(qos_rule_type, *, fields=None)`

Get details about single QoS rule type ⭐

Parameters

qos_rule_type — The value can be the name of a QoS policy rule type or a QoSRuleType <#openstack.network.v2.qos_rule_type.QoSRuleType> instance.
fields — Limit the resource fields to fetch.

Returns: One QoSRuleType <#openstack.network.v2.qos_rule_type.QoSRuleType>

Raises NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found. 💀

🎨 `qos_rule_types(**query)`

Return a generator of QoS rule types 🍓

Parameters

query —

Optional query parameters to be sent to limit the resources returned. Valid parameters include:

type: The type of the QoS rule type.

Returns: A generator of QoS rule type objects

🛰️ Agent Operations

okay so this next bit has a big ol' constructor signature and bestie I need you to just breathe — you don't have to type this out, it's the proxy class showing you all its little settings 🫶

class openstack.network.v2._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

🤖 `agents(**query)`

Return a generator of network agents — all the little helpers, lowkey obsessed 🐝

Parameters

query —

Optional query parameters to be sent to limit the resources being returned.

agent_type: Agent type.
availability_zone: The availability zone for an agent.
binary — the name of the agent's application binary. like, the executable itself 🖥️
description — the description of the agent. the lil blurb bestie 📝
host — the host (host name or host address) the agent is running on 🏠
topic — the message queue topic used 📨
is_admin_state_up — the administrative state of the agent 👑
is_alive — whether the agent is alive. vibe check 💀

Returns: a generator of agents ✨

delete_agent(agent, ignore_missing=True)

Delete a network agent 🗑️

Parameters:

agent — the value can be the ID of a agent or a Agent <#openstack.network.v2.agent.Agent> instance.
ignore_missing — when set to False NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the agent does not exist. When set to True, no exception will be set when attempting to delete a nonexistent agent. (yes, "no exception will be set" — that's the original wording, don't come for me 😭)

Returns: None

get_agent(agent, *, fields=None)

Get a single network agent 🕵️‍♀️

Parameters:

agent — the value can be the ID of a agent or a Agent <#openstack.network.v2.agent.Agent> instance.
fields — limit the resource fields to fetch. only grab what u asked for 💅

Returns: one Agent <#openstack.network.v2.agent.Agent>

Raises NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found. 🫠

update_agent(agent, **attrs)

Update a network agent 🔧

Parameters:

agent — the value can be the ID of a agent or a Agent <#openstack.network.v2.agent.Agent> instance.
attrs — the attributes to update on the agent represented by value.

Returns: one Agent <#openstack.network.v2.agent.Agent>

network_hosting_dhcp_agents(network, **query)

A generator of DHCP agents hosted on a network 🌐

Parameters:

network — the instance of Network <#openstack.network.v2.network.Network>
query — optional query parameters to be sent to limit the resources returned.

Returns: a generator of hosted DHCP agents 🎀

routers_hosting_l3_agents(router, **query)

Return a generator of L3 agent hosting a router 🛰️

Parameters:

router — either the router id or an instance of Router <#openstack.network.v2.router.Router>
query — optional query parameters to be sent to limit the resources returned

Returns: a generator of Router L3 Agents

agent_hosted_routers(agent, **query)

Return a generator of routers hosted by a L3 agent 🔥

Parameters:

agent — either the agent id of an instance of Agent
query — optional query parameters to be sent to limit the resources returned

Returns: a generator of routers

add_router_to_agent(agent, router, *, ha_chassis_priority=None)

Add router to L3 agent ➕

Parameters:

agent — either the id of an agent Agent <#openstack.network.v2.agent.Agent> instance
router — a router instance
ha_chassis_priority — optional HA_Chassis priority, that could be [0, 32767].

Returns: Agent with attached router 🫶

remove_router_from_agent(agent, router)

Remove router from L3 agent ➖

Parameters:

agent — either the id of an agent or an Agent <#openstack.network.v2.agent.Agent> instance
router — a router instance

Returns: Agent with removed router

🎀 RBAC Operations 🎀

Okay so this is the whole RBAC era of the network proxy, and yes the class signature is a MOOD, it's giving "we accept everything" energy:

class openstack.network.v2._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

create_rbac_policy(**attrs)

Create a new RBAC policy from attributes ✨

Parameters:

attrs — keyword arguments which will be used to create a RBACPolicy <#openstack.network.v2.rbac_policy.RBACPolicy>, comprised of the properties on the RBACPolicy class.

Returns: the results of RBAC policy creation 👑

delete_rbac_policy(rbac_policy, ignore_missing=True)

Delete a RBAC policy 🗑️

Parameters:

rbac_policy — the value can be either the ID of a RBAC policy or a RBACPolicy <#openstack.network.v2.rbac_policy.RBACPolicy> instance.
ignore_missing — when set to False NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the RBAC policy does not exist. When set to True, no exception will be set when attempting to delete a nonexistent RBAC policy.

Returns: None

find_rbac_policy(rbac_policy, ignore_missing=True, **query)

Find a single RBAC policy 🔍

Parameters:

rbac_policy — the ID of a RBAC policy.
ignore_missing — when set to False NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the resource does not exist. When set to True, None will be returned when attempting to find a nonexistent resource. (so chill of it tbh)
query — any additional parameters to be passed into underlying methods. such as query filters.

Returns: one RBACPolicy <#openstack.network.v2.rbac_policy.RBACPolicy> or None

get_rbac_policy(rbac_policy, *, fields=None)

Get a single RBAC policy 💖

Parameters:

rbac_policy — the value can be the ID of a RBAC policy or a RBACPolicy <#openstack.network.v2.rbac_policy.RBACPolicy> instance.
fields — limit the resource fields to fetch.

Returns: one RBACPolicy <#openstack.network.v2.rbac_policy.RBACPolicy>

Raises NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found. 😭

rbac_policies(**query)

Return a generator of RBAC policies 🌈

Parameters:

query — optional query parameters to be sent to limit the resources being returned. available parameters include:
- action — RBAC policy action
- object_type — type of the object that the RBAC policy affects
- target_project_id — ID of the project that the RBAC policy affects
- project_id — owner project ID

Returns: a generator of rbac objects

update_rbac_policy(rbac_policy, **attrs)

Update a RBAC policy 🔧

Parameters:

rbac_policy — either the id of a RBAC policy or a RBACPolicy <#openstack.network.v2.rbac_policy.RBACPolicy> instance.
attrs — the attributes to update on the RBAC policy represented by rbac_policy.

Returns: the updated RBAC policy ✨

💅 Listener Operations 💅

And here's the listener era — same proxy, same giant signature, no we're not retyping it differently bestie, it's literally identical:

class openstack.network.v2._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

create_listener(**attrs)

Create a new listener from attributes 🎧

Parameters:

attrs — keyword arguments which will be used to create a Listener <#openstack.network.v2.listener.Listener>, comprised of the properties on the Listener class.

Returns: the results of listener creation 🦋

delete_listener(listener, ignore_missing=True)

Delete a listener 🗑️

listener — bestie, this is either the ID of a listner or a Listener instance (openstack.network.v2.listener.Listener), your call 💅
ignore_missing — set it to False and NotFoundException (openstack.exceptions.NotFoundException) gets thrown the moment the listner doesn't exist. Set it to True and nothing happens when you try to delete a listener that was never there. no drama, no exception 🫶

Returns None

✨ `find_listener(name_or_id, ignore_missing=True, **query)` ✨

Find a single listener 🔍

Parameters

name_or_id — the name or ID of a listener. that's it, that's the whole vibe.
ignore_missing — False means NotFoundException (openstack.exceptions.NotFoundException) goes off when the resource doesn't exist. True means you just get None back when you go looking for a resource that isn't there. gentle rejection, honestly 💔
query — any extra params you wanna pass down into the underlying methods. like query filters and stuff ✨

Returns One Listener (openstack.network.v2.listener.Listener) or None

🌸 `get_listener(listener)` 🌸

Get a single listener, just the one, main character energy 👑

Parameters listener — the value can be the ID of a listener or a Listener (openstack.network.v2.listener.Listener) instance.

Returns One Listener (openstack.network.v2.listener.Listener)

Raises NotFoundException (openstack.exceptions.NotFoundException) when no resource can be found. like, it's simply not there bestie 😭

🦋 `listeners(**query)` 🦋

Return a generator of listeners — a whole lil stream of them, iconic 🎀

Parameters query —

Optional query parameters you send to limit the resources being returned. Valid parameters are:

connection_limit: The maximum number of connections permitted for the load-balancer.
default_pool_id: The ID of the default pool.
default_tls_container_ref: A reference to a container of TLS secret.
description: The description of a listener.
is_admin_state_up: The administrative state of the listener.
name: The name of a listener.
project_id: The ID of the project associated with a listener.
protocol: The protocol of the listener.
protocol_port: Port the listener will listen to.

Returns A generator of listener objects

💜 `update_listener(listener, **attrs)` 💜

Update a listener. glow-up time ✨

Parameters

listener — either the id of a listener or a Listener (openstack.network.v2.listener.Listener) instance.
attrs — the attributes to update on the listener represented by listener.

Returns The updated listener

🌈 Subnet Operations 🌈

class openstack.network.v2._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

⭐ `create_subnet(**attrs)` ⭐

Create a new subnet from attributes. brand new subnet, freshly served 🍓

Parameters attrs — keyword arguments which will be used to create a Subnet (openstack.network.v2.subnet.Subnet), comprised of the properties on the Subnet class.

Returns The results of subnet creation

🎀 `delete_subnet(subnet, ignore_missing=True, if_revision=None)` 🎀

Delete a subnet. bye bestie 👋

Parameters

subnet — the value can be either the ID of a subnet or a Subnet (openstack.network.v2.subnet.Subnet) instance.
ignore_missing — when set to False, NotFoundException (openstack.exceptions.NotFoundException) will be raised when the subnet does not exist. When set to True, no exception will be set when attempting to delete a nonexistent subnet. so chill.
if_revision — revision to put in If-Match header of update request to perform compare-and-swap update.

Returns None

🔥 `find_subnet(name_or_id, ignore_missing=True, **query)` 🔥

Find a single subnet

Parameters

name_or_id — the name or ID of a subnet.
ignore_missing — when set to False, NotFoundException (openstack.exceptions.NotFoundException) will be raised when the resource does not exist. When set to True, None will be returned when attempting to find a nonexistent resource.
query — any additional parameters to be passed into underlying methods. such as query filters.

Returns One Subnet (openstack.network.v2.subnet.Subnet) or None

🧚 `get_subnet(subnet, *, fields=None)` 🧚

Get a single subnet

Parameters

subnet — the value can be the ID of a subnet or a Subnet (openstack.network.v2.subnet.Subnet) instance.
fields — limit the resource fields to fetch. picky, and honestly? valid 💅

Returns One Subnet (openstack.network.v2.subnet.Subnet)

Raises NotFoundException (openstack.exceptions.NotFoundException) when no resource can be found.

🌟 `subnets(**query)` 🌟

Return a generator of subnets

Parameters query —

Optional query parameters to be sent to limit the resources being returned. Available parameters include:

cidr: Subnet CIDR
description: The subnet description
gateway_ip: Subnet gateway IP address
ip_version: Subnet IP address version
ipv6_address_mode: The IPv6 address mode
ipv6_ra_mode: The IPv6 router advertisement mode
is_dhcp_enabled: Subnet has DHCP enabled (boolean)
name: Subnet name
network_id: ID of network that owns the subnets
project_id: Owner project ID
subnet_pool_id: The subnet pool ID from which to obtain a CIDR.

Returns A generator of subnet objects

🎀 `update_subnet(subnet, if_revision=None, **attrs)` 🎀

Update a subnet

Parameters

subnet — either the id of a subnet or a Subnet (openstack.network.v2.subnet.Subnet) instance.
if_revision — revision to put in If-Match header of update request to perform compare-and-swap update.
attrs — the attributes to update on the subnet represented by subnet.

Returns The updated subnet

💖 `create_subnet_pool(**attrs)` 💖

Create a new subnet pool from attributes

Parameters attrs — keyword arguments which will be used to create a SubnetPool (openstack.network.v2.subnet_pool.SubnetPool), comprised of the properties on the SubnetPool class.

Returns The results of subnet pool creation

🦋 `delete_subnet_pool(subnet_pool, ignore_missing=True)` 🦋

Delete a subnet pool

Parameters

subnet_pool — the value can be either the ID of a subnet pool or a SubnetPool (openstack.network.v2.subnet_pool.SubnetPool) instance.
ignore_missing — when set to False, NotFoundException (openstack.exceptions.NotFoundException) will be raised when the subnet pool does not exist. When set to True, no exception will be set when attempting to delete a nonexistent subnet pool.

Returns None

🌸 `find_subnet_pool(name_or_id, ignore_missing=True, **query)` 🌸

Find a single subnet pool

Parameters

name_or_id — the name or ID of a subnet pool.
ignore_missing — when it’s set to False, NotFoundException <#openstack.exceptions.NotFoundException> gets raised if the resource doesn’t exist. When it’s True, you just get None back when the thing you’re looking for isn’t there. chill find behavior, no cap ✨
query — any extra parameters passed into the underlying methods. such as query filters. iykyk 🫶

Returns: One SubnetPool <#openstack.network.v2.subnet_pool.SubnetPool> or None

🌸 `get_subnet_pool(subnet_pool, *, fields=None)`

Get a single subnet pool. one pool, coming right up 💅

Parameters:

subnet_pool — the value can be the ID of a subnet pool or a SubnetPool <#openstack.network.v2.subnet_pool.SubnetPool> instance.
fields — limit the resource fields to fetch.

Returns: One SubnetPool <#openstack.network.v2.subnet_pool.SubnetPool>

Raises NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found. so if it’s not there, it will absolutely let you know 😭

🦋 `subnet_pools(**query)`

Return a generator of subnet pools. generator girlie behavior 🎀

Parameters:

query — optional query parameters to be sent to limit the resources being returned. Available parameters include:
- address_scope_id: Subnet pool address scope ID
- description: The subnet pool description
- ip_version: The IP address family
- is_default: Subnet pool is the default (boolean)
- is_shared: Subnet pool is shared (boolean)
- name: Subnet pool name
- project_id: Owner project ID

Returns: A generator of subnet pool objects

💜 `update_subnet_pool(subnet_pool, **attrs)`

Update a subnet pool. glow-up time ✨

Parameters:

subnet_pool — either the ID of a subnet pool or a SubnetPool <#openstack.network.v2.subnet_pool.SubnetPool> instance.
attrs — the attributes to update on the subnet pool represented by subnet_pool.

Returns: The updated subnet pool

🎀 Load Balancer Operations 🎀

       class openstack.network.v2._proxy.Proxy(session, *, service_type=None,
       service_name=None, interface=None, region_name=None,
       endpoint_override=None, version=None, auth=None, user_agent=None,
       connect_retries=None, logger=None, allow=None, additional_headers=None,
       client_name=None, client_version=None, allow_version_hack=None,
       global_request_id=None, min_version=None, max_version=None,
       default_microversion=None, status_code_retries=None,
       retriable_status_codes=None, raise_exc=None, rate_limit=None,
       concurrency=None, connect_retry_delay=None,
       status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
       prometheus_counter=None, prometheus_histogram=None,
       influxdb_config=None, influxdb_client=None)

👑 `create_load_balancer(**attrs)`

Create a new load balancer from attributes. main character resource creation 💅

Parameters:

attrs — keyword arguments which will be used to create a LoadBalancer <#openstack.network.v2.load_balancer.LoadBalancer>, comprised of the properties on the LoadBalancer class.

Returns: The results of load balancer creation

🌈 `delete_load_balancer(load_balancer, ignore_missing=True)`

Delete a load balancer. bye bestie 🫶

Parameters:

load_balancer — the value can be the ID of a load balancer or a LoadBalancer <#openstack.network.v2.load_balancer.LoadBalancer> instance.
ignore_missing — when set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the load balancer does not exist. When set to True, no exception will be set when attempting to delete a nonexistent load balancer.

Returns: None

⭐ `find_load_balancer(name_or_id, ignore_missing=True, **query)`

Find a single load balancer. scavenger hunt but make it cloud 🔥

Parameters:

name_or_id — the name or ID of a load balancer.
ignore_missing — when set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the resource does not exist. When set to True, None will be returned when attempting to find a nonexistent resource.
query — any additional parameters to be passed into underlying methods. such as query filters.

Returns: One LoadBalancer <#openstack.network.v2.load_balancer.LoadBalancer> or None

💖 `get_load_balancer(load_balancer)`

Get a single load balancer. just the one, iconic 🦋

Parameters:

load_balancer — the value can be the ID of a load balancer or a LoadBalancer <#openstack.network.v2.load_balancer.LoadBalancer> instance.

Returns: One LoadBalancer <#openstack.network.v2.load_balancer.LoadBalancer>

Raises NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found. no resource, no vibes 💀

🌸 `load_balancers(**query)`

Return a generator of load balancers. a whole little lineup ✨

Parameters:

query — optional query parameters to be sent to limit the resources being returned.

Returns: A generator of load balancer objects

🎀 `update_load_balancer(load_balancer, **attrs)`

Update a load balancer. little refresh, little slay 💅

Parameters:

load_balancer — either the id of a load balancer or a LoadBalancer <#openstack.network.v2.load_balancer.LoadBalancer> instance.
attrs — the attributes to update on the load balancer represented by load_balancer.

Returns: The updated load balancer

🌸 Health Monitor Operations 🌸

       class openstack.network.v2._proxy.Proxy(session, *, service_type=None,
       service_name=None, interface=None, region_name=None,
       endpoint_override=None, version=None, auth=None, user_agent=None,
       connect_retries=None, logger=None, allow=None, additional_headers=None,
       client_name=None, client_version=None, allow_version_hack=None,
       global_request_id=None, min_version=None, max_version=None,
       default_microversion=None, status_code_retries=None,
       retriable_status_codes=None, raise_exc=None, rate_limit=None,
       concurrency=None, connect_retry_delay=None,
       status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
       prometheus_counter=None, prometheus_histogram=None,
       influxdb_config=None, influxdb_client=None)

🫶 `create_health_monitor(**attrs)`

Create a new health monitor from attributes. keeping an eye on things, respectfully 👀

Parameters:

attrs — keyword arguments which will be used to create a HealthMonitor <#openstack.network.v2.health_monitor.HealthMonitor>, comprised of the properties on the HealthMonitor class.

Returns: The results of health monitor creation

🦋 `delete_health_monitor(health_monitor, ignore_missing=True)`

Delete a health monitor. removing the watcher, dramatic but valid 😭

Parameters:

health_monitor — the value can be either the ID of a health monitor or a HealthMonitor <#openstack.network.v2.health_monitor.HealthMonitor> instance.
ignore_missing — when set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the health monitor does not exist. When set to True, no exception will be set when attempting to delete a nonexistent health monitor.

Returns: None

💜 `find_health_monitor(name_or_id, ignore_missing=True, **query)`

Find a single health monitor. finding your fave monitor 🔍

Parameters:

name_or_id — the name or ID of a health monitor.
ignore_missing — when set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the resource does not exist. When set to True, None will be returned when attempting to find a nonexistent resource.
query — any additional parameters to be passed into underlying methods. such as query filters.

Returns: One HealthMonitor <#openstack.network.v2.health_monitor.HealthMonitor> or None

🌈 `get_health_monitor(health_monitor)`

Get a single health monitor. one monitor, fully fetched ✨

Parameters:

health_monitor — the value can be the ID of a health monitor or a HealthMonitor <#openstack.network.v2.health_monitor.HealthMonitor> instance.

Returns: One HealthMonitor <#openstack.network.v2.health_monitor.HealthMonitor>

Raises NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found. if it’s missing, it’s missing 💀

⭐ `health_monitors(**query)`

Return a generator of health monitors. monitor generator era 🎀

Parameters:

query —

Optional query parameters to be sent to limit the resources being returned, bestie — valid ones are:

delay — the time in milliseconds between sending probes. ⏱️
expected_codes — the expected HTTP codes for a pssing HTTP(S) monitor. 💅
http_method — the HTTP method a monitor uses for requests.
is_admin_state_up — the administrative state of a health monitor.
max_retries — the maximum consecutive health probe attempts.
project_id — the ID of the project this health monitor is associated with.
timeout — the maximum number of milliseconds for a monitor to wait for a connection to be established before it times out.
type — the type of probe sent by the load balancer for health check, which can be PING, TCP, HTTP or HTTPS.
url_path — the path portion of a URI that will be probed.

Returns — a generator of health monitor objects. ✨

`update_health_monitor(health_monitor, **attrs)`

Update a health monitor. 🫶

Parameters

health_monitor — either the id of a health monitor or a HealthMonitor <#openstack.network.v2.health_monitor.HealthMonitor> instance.
attrs — the attributes to update on the health monitor represented by value.

Returns — the updated health monitor. 💖

🎀 Metering Label Operations 🎀

Okay so this is the proxy class signature, and it is long — do not panic, just copy/paste energy:

class openstack.network.v2._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

`create_metering_label(**attrs)`

Create a new metering label from attributes. 🎀

Parameters

attrs — keyword arguments which will be used to create a MeteringLabel <#openstack.network.v2.metering_label.MeteringLabel>, comprised of the properties on the MeteringLabel class.

Returns — the results of metering label creation. 🌸

`delete_metering_label(metering_label, ignore_missing=True)`

Delete a metering label. 🫶

Parameters

metering_label — the value can be either the ID of a metering label or a MeteringLabel <#openstack.network.v2.metering_label.MeteringLabel> instance.
ignore_missing — when set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the metering label does not exist. When set to True, no exception will be set when attempting to delete a nonexistent metering label. 😭

Returns — None.

`find_metering_label(name_or_id, ignore_missing=True, **query)`

Find a single metering label. 🔍

Parameters

name_or_id — the name or ID of a metering label.
ignore_missing — when set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the resource does not exist. When set to True, None will be returned when attempting to find a nonexistent resource.
query — any additional parameters to be passed into underlying methods. such as query filters.

Returns — one MeteringLabel <#openstack.network.v2.metering_label.MeteringLabel> or None. 💜

`get_metering_label(metering_label, *, fields=None)`

Get a single metering label. ✨

Parameters

metering_label — the value can be the ID of a metering label or a MeteringLabel <#openstack.network.v2.metering_label.MeteringLabel> instance.
fields — limit the resource fields to fetch.

Returns — one MeteringLabel <#openstack.network.v2.metering_label.MeteringLabel>. 🌈

Raises — NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found.

`metering_labels(**query)`

Return a generator of metering labels. 🦋

Parameters

query — optional query parameters to be sent to limit the resources being returned. Valid parameters are:
- description — description of a metering label.
- name — name of a metering label.
- is_shared — boolean indicating whether a metering label is shared.
- project_id — the ID of the project a metering label is associated with.

Returns — a generator of metering label objects. ⭐

`update_metering_label(metering_label, **attrs)`

Update a metering label. 💅

Parameters

metering_label — either the id of a metering label or a MeteringLabel <#openstack.network.v2.metering_label.MeteringLabel> instance.
attrs — the attributes to update on the metering label represented by metering_label.

Returns — the updated metering label. 💖

`create_metering_label_rule(**attrs)`

Create a new metering label rule from attributes. 🎀

Parameters

attrs — keyword arguments which will be used to create a MeteringLabelRule <#openstack.network.v2.metering_label_rule.MeteringLabelRule>, comprised of the properties on the MeteringLabelRule class.

Returns — the results of metering label rule creation. 🌸

`delete_metering_label_rule(metering_label_rule, ignore_missing=True)`

Delete a metering label rule. 🫶

Parameters

metering_label_rule — the value can be either the ID of a metering label rule or a MeteringLabelRule <#openstack.network.v2.metering_label_rule.MeteringLabelRule> instance.
ignore_missing — when set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the metering label rule does not exist. When set to True, no exception will be set when attempting to delete a nonexistent metering label rule. 😭

Returns — None.

`find_metering_label_rule(name_or_id, ignore_missing=True, **query)`

Find a single metering label rule. 🔍

Parameters

name_or_id — the name or ID of a metering label rule.
ignore_missing — when set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the resource does not exist. When set to True, None will be returned when attempting to find a nonexistent resource.
query — any additional parameters to be passed into underlying methods. such as query filters.

Returns — one MeteringLabelRule <#openstack.network.v2.metering_label_rule.MeteringLabelRule> or None. 💜

`get_metering_label_rule(metering_label_rule, *, fields=None)`

Get a single metering label rule. ✨

Parameters

metering_label_rule — the value can be the ID of a metering label rule or a MeteringLabelRule <#openstack.network.v2.metering_label_rule.MeteringLabelRule> instance.
fields — limit the resource fields to fetch.

Returns — one MeteringLabelRule <#openstack.network.v2.metering_label_rule.MeteringLabelRule>. 🌈

Raises — NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found.

`metering_label_rules(**query)`

Return a generator of metering label rules. 🦋

Parameters

query — optional query parameters to be sent to limit the resources being returned. Valid parameters are:
- direction — the direction in which metering label rule is applied.
- metering_label_id — the ID of a metering label this rule is associated with.
- project_id — the ID of the project the metering label rule is associated with.

🎀 Segment Operations 🎀

Bestie, we're in segment territory now, and the proxy class is the exact same absolute unit as before — like, literally identical signature, no cap, so imma paste it verbatim because I refuse to let a single character slip:

class openstack.network.v2._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

Okay so the segment methods themselves are these cuties 👇

`create_segment(**attrs)`

Make a brand new segment out of attributes. Manifesting a segment rn ✨

Parameters

attrs — keyword arguments that get used to create a Segment <#openstack.network.v2.segment.Segment>, all made up of the properties on the Segment class.

Returns

The results of segment creation 🌱

`delete_segment(segment, ignore_missing=True)`

Yeet a segment. Bye bestie 💅

Parameters

segment — the value can be either the ID of a segment or a Segment <#openstack.network.v2.segment.Segment> instance.
ignore_missing — when set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the segment does not exist. When set to True, no exception will be set when attempting to delete a nonexistent segment.

Returns

None (the void, the emptiness, the peace 🫶)

`find_segment(name_or_id, ignore_missing=True, **query)`

Find one single segment. Detective mode activated 🔍

Parameters

name_or_id — the name or ID of a segment.
ignore_missing — when set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the resource does not exist. When set to True, None will be returned when attempting to find a nonexistent resource.
query — any additional parameters to be passed into underlying methods. such as query filters.

Returns

One Segment <#openstack.network.v2.segment.Segment> or None

`get_segment(segment, *, fields=None)`

Grab a single segment — like, just the one, very demure 🎀

Parameters

segment — the value can be the ID of a segment or a Segment <#openstack.network.v2.segment.Segment> instance.
fields — limit the resource fields to fetch.

Returns

One Segment <#openstack.network.v2.segment.Segment>

Raises NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found. 😭

`segments(**query)`

Return a generator of segments — an infinite scroll but make it networking 🌀

Parameters

query —

Optional query parameters to be sent to limit the resources being returned. Available parameters include:

description: the segment description
name: name of the segments
network_id: ID of the network that owns the segments
network_type: network type for the segments
physical_network: physical network name for the segments
segmentation_id: segmentation ID for the segments

Returns

A generator of segment objects

`update_segment(segment, **attrs)`

Update a segment. Glow-up arc, but for data 🦋

Parameters

segment — either the id of a segment or a Segment <#openstack.network.v2.segment.Segment> instance.
attrs — the attributes to update on the segment represented by segment.

Returns

The update segment (that's the original wording, do not @ me 💀)

🌈 Flavor Operations 🌈

And now for flavors — no, not the eating kind, bestie, these are network service flavors. The proxy signature? Same iconic specimen, same energy:

class openstack.network.v2._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

`create_flavor(**attrs)`

Create a new network service flavor from attributes. Chef's kiss 👨‍🍳💋

Parameters

attrs — keyword arguments which will be used to create a Flavor <#openstack.network.v2.flavor.Flavor>, comprised of the properties on the Flavor class.

Returns

The results of flavor creation ✨

`delete_flavor(flavor, ignore_missing=True)`

Delete a network service flavor. It's giving departure 💔

Parameters

flavor — the value can be either the ID of a flavor or a Flavor <#openstack.network.v2.flavor.Flavor> instance.
ignore_missing — when set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the flavor does not exist. When set to True, no exception will be set when attempting to delete a nonexistent flavor.

Returns

None

`find_flavor(name_or_id, ignore_missing=True, **query)`

Find a single network service flavor. Highkey a scavenger hunt 🕵️‍♀️

Parameters

name_or_id — the name or ID of a flavor.
ignore_missing — when set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the resource does not exist. When set to True, None will be returned when attempting to find a nonexistent resource.
query — any additional parameters to be passed into underlying methods. such as query filters.

Returns

One Flavor <#openstack.network.v2.flavor.Flavor> or None

`get_flavor(flavor, *, fields=None)`

Get a single network service flavor. Just the one, thank you 💅

Parameters

flavor — the value can be the ID of a flavor or a Flavor <#openstack.network.v2.flavor.Flavor> instance.
fields — limit the resource fields to fetch.

Returns

One Flavor <#openstack.network.v2.flavor.Flavor>

Raises NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found. 🙈

`update_flavor(flavor, **attrs)`

Update a network service flavor — transformation era 🔥

Parameters

flavor — either the id of a flavor or a Flavor <#openstack.network.v2.flavor.Flavor> instance.
attrs — the attributes to update on the flavor represented by flavor.

Returns

The updated flavor

`flavors(**query)`

Return a generator of network service flavors. Collect them all, Pokémon style 🍓

Parameters

query —

Optional query parameters to be sent to limit the resources being returned. Valid parameters include:

description: the description of a flavor.
is_enabled: whether a flavor is enabled.
name: the name of a flavor.
service_type: the service type to which a falvor applies.

Okay so that last one says falvor in the source and I am keeping it, typo and all, because the docs said it and I don't make the rules. We love a quirky original 💀💖

Returns

A generator of flavor objects

💖 Service Profile Operations

okay so this chunk is all about service flavor profiles — the matchmaking between flavors and service profiles, basically. The constructor is the same big Proxy signature every time, so here it is exactly:

class openstack.network.v2._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

`associate_flavor_with_service_profile(flavor, service_profile)`

Associate network flavor with service profile. Bestie, this is the “they’re together now” method. ✨

Parameters

flavor — Either the id of a flavor or a Flavor <#openstack.network.v2.flavor.Flavor> instance.
service_profile — The value can be either the ID of a service profile or a ServiceProfile <#openstack.network.v2.service_profile.ServiceProfile> instance.

Returns —

`disassociate_flavor_from_service_profile(flavor, service_profile)`

Disassociate network flavor from service profile. The “we need to talk” method, lowkey. 💔

Parameters

flavor — Either the id of a flavor or a Flavor <#openstack.network.v2.flavor.Flavor> instance.
service_profile — The value can be either the ID of a service profile or a ServiceProfile <#openstack.network.v2.service_profile.ServiceProfile> instance.

Returns —

`create_service_profile(**attrs)`

Create a new network service flavor profile from attributes. It’s giving “make a whole new profile from vibes and kwargs.” 🎀

Parameters

attrs — Keyword arguments which will be used to create a ServiceProfile <#openstack.network.v2.service_profile.ServiceProfile>, comprised of the properties on the ServiceProfile class.

Returns — The results of service profile creation

`delete_service_profile(service_profile, ignore_missing=True)`

Delete a network service flavor profile. Poof, gone, no cap. 🫧

Parameters

service_profile — The value can be either the ID of a service profile or a ServiceProfile <#openstack.network.v2.service_profile.ServiceProfile> instance.
ignore_missing — When set to False NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the service profile does not exist. When set to True, no exception will be set when attempting to delete a nonexistent service profile.

Returns — None

`find_service_profile(name_or_id, ignore_missing=True, **query)`

Find a single network service flavor profile. Detective mode: on. 🔍

Parameters

name_or_id — The name or ID of a service profile.
ignore_missing — When set to False NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the resource does not exist. When set to True, None will be returned when attempting to find a nonexistent resource.
query — Any additional parameters to be passed into underlying methods. such as query filters.

Returns — One ServiceProfile <#openstack.network.v2.service_profile.ServiceProfile> or None

`get_service_profile(service_profile, *, fields=None)`

Get a single network service flavor profile. This one pulls up the whole profile card. 💅

Parameters

service_profile — The value can be the ID of a service_profile or a ServiceProfile <#openstack.network.v2.service_profile.ServiceProfile> instance.
fields — Limit the resource fields to fetch.

Returns — One ServiceProfile <#openstack.network.v2.service_profile.ServiceProfile>

Raises NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found.

`service_profiles(**query)`

Return a generator of network service flavor profiles. It’s a whole scrollable feed of service profiles, fr fr. 🌸

Parameters

query — Optional query parameters to be sent to limit the resources returned. Available parameters inclue:
- description: The description of the service flavor profile
- driver: Provider driver for the service flavor profile
- is_enabled: Whether the profile is enabled
- project_id: The owner project ID

Returns — A generator of service profile objects

`update_service_profile(service_profile, **attrs)`

Update a network flavor service profile. Glow-up time. ✨

Parameters

service_profile — Either the id of a service profile or a ServiceProfile <#openstack.network.v2.service_profile.ServiceProfile> instance.
attrs — The attributes to update on the service profile represented by service_profile.

Returns — The updated service profile

🏷️ Tag Operations

Same Proxy constructor, same exact signature. We’re not retyping it in a different font, bestie — here it is:

class openstack.network.v2._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

`set_tags(resource, tags)`

Replace tags of a specified resource with specified tags. Out with the old tag vibes, in with the new. 🎀

Parameters

resource — Resource <#openstack.resource.Resource> instance.
tags ("list") — New tags to be set.

Returns — The updated resource

🦋 VPNaaS Operations

Another Proxy constructor moment, same exact parameters. Iconic copy-paste behavior, honestly:

class openstack.network.v2._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

`create_vpn_endpoint_group(**attrs)`

Create a new vpn endpoint group from attributes. New group, new VPN era. 🔥

Parameters

attrs — Keyword arguments which will be used to create a VpnEndpointGroup <#openstack.network.v2.vpn_endpoint_group.VpnEndpointGroup>, comprised of the properties on the VpnEndpointGroup class.

Returns — The results of vpn endpoint group creation.

`delete_vpn_endpoint_group(vpn_endpoint_group, ignore_missing=True)`

Delete a vpn service. (Yes, that’s the wording, bestie — keep it exactly as it is. 💀)

Parameters

vpn_endpoint_group — The value can be either the ID of a vpn service or a VpnEndpointGroup <#openstack.network.v2.vpn_endpoint_group.VpnEndpointGroup> instance.
ignore_missing — When set to False NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the vpn service does not exist. When set to True, no exception will be set when attempting to delete a nonexistent vpn service.

Returns — None

`find_vpn_endpoint_group(name_or_id, ignore_missing=True, **query)`

Find a single vpn service. Searching high and low. 🔍

Parameters

name_or_id — The name or ID of a vpn service.
ignore_missing — When set to False NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the resource does not exist. When set to True, None will be returned when attempting to find a nonexistent resource.
query — Any additional parameters to be passed into underlying methods. such as query filters.

Returns — One VpnEndpointGroup <#openstack.network.v2.vpn_endpoint_group.VpnEndpointGroup> or None

`get_vpn_endpoint_group(vpn_endpoint_group, *, fields=None)`

Get a single vpn service. Pulling up the endpoint group’s whole profile. 💅

Parameters

vpn_endpoint_group — The value can be the ID of a vpn service or a VpnEndpointGroup <#openstack.network.v2.vpn_endpoint_group.VpnEndpointGroup> instance.
fields — limits which resource fields get fetched ✨ (yes, this is the tail of the previous one, we're rolling straight in, no awkward pause 🫶)

🌸 `vpn_endpoint_groups(**query)`

Returns a generator of vpn services, bestie — a whole stream of them, one at a time 💫

Parameters

query — optional query parameters that get sent along to limit the resources being returned.

Returns

A generator of vpn service objects — VpnEndpointGroup (openstack.network.v2.vpn_endpoint_group.VpnEndpointGroup) 👑

🦋 `update_vpn_endpoint_group(vpn_endpoint_group, **attrs)`

Updates a vpn service. Glow-up time 💅

Parameters

vpn_endpoint_group — either the id of a vpn service or a VpnEndpointGroup (openstack.network.v2.vpn_endpoint_group.VpnEndpointGroup) instance.
attrs — the attributes to update on the VPN service represented by vpn_endpoint_group.

Returns

The updated vpnservice ✨

🎀 `create_vpn_ipsec_site_connection(**attrs)`

Creates a brand new IPsec site connection from attributes. New connection just dropped 📥

Parameters

attrs — keyword arguments which will be used to create a VpnIPSecSiteConnection (openstack.network.v2.vpn_ipsec_site_connection.VpnIPSecSiteConnection), comprised of the properties on the IPSecSiteConnection class.

Returns

The results of IPsec site connection creation 🌟

💜 `find_vpn_ipsec_site_connection(name_or_id, ignore_missing=True, **query)`

Finds a single IPsec site connection. Scavenger hunt but make it cloud ☁️

Parameters

name_or_id — the name or ID of an IPsec site connection.
ignore_missing — when set to False, NotFoundException (openstack.exceptions.NotFoundException) will be raised when the resource does not exist. When set to True, None will be returned when attempting to find a nonexistent resource. (Default is True, iykyk 💫)
query — any additional parameters to be passed into underlying methods such as query filters.

Returns

One VpnIPSecSiteConnection (openstack.network.v2.vpn_ipsec_site_connection.VpnIPSecSiteConnection) or None

🧚 `get_vpn_ipsec_site_connection(ipsec_site_connection, *, fields=None)`

Gets a single IPsec site connection. Just the one, thanks 🫶

Parameters

ipsec_site_connection — the value can be the ID of an IPsec site connection or a VpnIPSecSiteConnection (openstack.network.v2.vpn_ipsec_site_connection.VpnIPSecSiteConnection) instance.
fields — limit the resource fields to fetch.

Returns

One VpnIPSecSiteConnection (openstack.network.v2.vpn_ipsec_site_connection.VpnIPSecSiteConnection)

Raises

NotFoundException (openstack.exceptions.NotFoundException) when no resource can be found 😭

🌈 `vpn_ipsec_site_connections(**query)`

Returns a generator of IPsec site connections — the whole squad, delivered lazily 💫

Parameters

query — optional query parameters to be sent to limit the resources being returned.

Returns

A generator of IPsec site connection objects — VpnIPSecSiteConnection (openstack.network.v2.vpn_ipsec_site_connection.VpnIPSecSiteConnection)

🔥 `update_vpn_ipsec_site_connection(ipsec_site_connection, **attrs)`

Updates a IPsec site connection. It's giving main character energy ✨

ipsec_site_connection

Either the id of an IPsec site connection or a VpnIPSecSiteConnection (openstack.network.v2.vpn_ipsec_site_connection.VpnIPSecSiteConnection) instance.

Parameters

attrs — the attributes to update on the IPsec site connection represented by ipsec_site_connection.

Returns

The updated IPsec site connection 💅

💀 `delete_vpn_ipsec_site_connection(ipsec_site_connection, ignore_missing=True)`

Deletes a IPsec site connection. Gone, gone, gone 🫡

Parameters

ipsec_site_connection — the value can be either the ID of an IPsec site connection, or a VpnIPSecSiteConnection (openstack.network.v2.vpn_ipsec_site_connection.VpnIPSecSiteConnection) instance.
ignore_missing — when set to False, NotFoundException (openstack.exceptions.NotFoundException) will be raised when the IPsec site connection does not exist. When set to True, no exception will be set when attempting to delete a nonexistent IPsec site connection.

Returns

None

🍓 `create_vpn_ike_policy(**attrs)`

Creates a new ike policy from attributes. Fresh policy, fresh vibes 📝

Parameters

attrs — keyword arguments which will be used to create a VpnIkePolicy (openstack.network.v2.vpn_ike_policy.VpnIkePolicy), comprised of the properties on the VpnIkePolicy class.

Returns

The results of ike policy creation ✨

🌸 `find_vpn_ike_policy(name_or_id, ignore_missing=True, **query)`

Finds a single ike policy. Detective era 🕵️‍♀️

Parameters

name_or_id — the name or ID of an IKE policy.
ignore_missing — when set to False, NotFoundException (openstack.exceptions.NotFoundException) will be raised when the resource does not exist. When set to True, None will be returned when attempting to find a nonexistent resource.
query — any additional parameters to be passed into underlying methods such as query filters.

Returns

One VpnIkePolicy (openstack.network.v2.vpn_ike_policy.VpnIkePolicy) or None.

🦋 `get_vpn_ike_policy(ike_policy, *, fields=None)`

Gets a single ike policy. One (1) policy, served fresh 🎀

Parameters

ike_policy — the value can be the ID of an IKE policy or a VpnIkePolicy (openstack.network.v2.vpn_ike_policy.VpnIkePolicy) instance.
fields — limit the resource fields to fetch.

Returns

One VpnIkePolicy (openstack.network.v2.vpn_ike_policy.VpnIkePolicy)

Raises

NotFoundException (openstack.exceptions.NotFoundException) when no resource can be found 😭

⭐ `vpn_ike_policies(**query)`

Returns a generator of IKE policies — plural, plentiful, powerful 💫

Parameters

query — optional query parameters to be sent to limit the resources being returned.

Returns

A generator of ike policy objects

👑 `update_vpn_ike_policy(ike_policy, **attrs)`

Updates an IKE policy. She's evolving 💅

ike_policy

Either the ID of an IKE policy or a VpnIkePolicy (openstack.network.v2.vpn_ike_policy.VpnIkePolicy) instance.

Parameters

attrs — the attributes to update on the ike policy represented by ike_policy.

Returns

The updated ike policy ✨

🙈 `delete_vpn_ike_policy(ike_policy, ignore_missing=True)`

Deletes an IKE policy. Byeee, no notes 🫶

Parameters

ike_policy — the value can be either the ID of an ike policy, or a VpnIkePolicy (openstack.network.v2.vpn_ike_policy.VpnIkePolicy) instance.
ignore_missing — when set to False, NotFoundException (openstack.exceptions.NotFoundException) will be raised when the ike policy does not exist. When set to True, no exception will be set when attempting to delete a nonexistent ike policy.

Returns

None

🧚 `create_vpn_ipsec_policy(**attrs)`

Creates a new IPsec policy from attributes. Building it from scratch, obsessed 🔨

Parameters

attrs — keyword arguments which will be used to create a VpnIpsecPolicy (openstack.network.v2.vpn_ipsec_policy.VpnIpsecPolicy), comprised of the properties on the VpnIpsecPolicy class.

Returns

The results of IPsec policy creation 🌟

💫 `find_vpn_ipsec_policy(name_or_id, ignore_missing=True, **query)`

Finds a single IPsec policy. One singular icon 🔍

Parameters

name_or_id — the name or ID of an IPsec policy.
ignore_missing — when set to False, NotFoundException (openstack.exceptions.NotFoundException) will be raised when the resource does not exist. When set to True, None will be returned when attempting to find a nonexistent resource.
query — any extra parameters you want passed down into the underlying methods, like query filters.

Returns — one VpnIpsecPolicy (openstack.network.v2.vpn_ipsec_policy.VpnIpsecPolicy) or None.

get_vpn_ipsec_policy(ipsec_policy, *, fields=None) — grab a single IPsec policy, no cap.

Parameters

ipsec_policy — this can be the ID of an IPcec policy or a VpnIpsecPolicy (openstack.network.v2.vpn_ipsec_policy.VpnIpsecPolicy) instance. (yes bestie, the original really says IPcec — we keep it exactly as-is 💅)
fields — limit the resource fields to fetch.

Returns — one VpnIpsecPolicy (openstack.network.v2.vpn_ipsec_policy.VpnIpsecPolicy).

Raises — NotFoundException (openstack.exceptions.NotFoundException) when no resource can be found.

vpn_ipsec_policies(**query) — return a generator of IPsec policies. It’s giving “all the policies, please.” ✨

Parameters

query — optional query parameters sent along to limit the resources being returned.

Returns — a generator of IPsec policy objects.

update_vpn_ipsec_policy(ipsec_policy, **attrs) — update an IPsec policy.

Ipsec_policy — either the id of an IPsec policy or a VpnIpsecPolicy (openstack.network.v2.vpn_ipsec_policy.VpnIpsecPolicy) instance.

Parameters

attrs — the attributes to update on the IPsec policy represented by ipsec_policy.

Returns — the updated IPsec policy.

delete_vpn_ipsec_policy(ipsec_policy, ignore_missing=True) — delete an IPsec policy. Bye bestie 👋

Parameters

ipsec_policy — the value can be either the ID of an IPsec policy, or a VpnIpsecPolicy (openstack.network.v2.vpn_ipsec_policy.VpnIpsecPolicy) instance.
ignore_missing — when set to False, NotFoundException (openstack.exceptions.NotFoundException) will be raised when the IPsec policy does not exist. When set to True, no exception will be set when attempting to delete a nonexistent IPsec policy.

Returns — None.

create_vpn_service(**attrs) — create a new vpn service from attributes. Main character creation energy 🔥

Parameters

attrs — keyword arguments which will be used to create a VpnService (openstack.network.v2.vpn_service.VpnService), comprised of the properties on the VpnService class.

Returns — the results of vpn service creation.

delete_vpn_service(vpn_service, ignore_missing=True) — delete a vpn service.

Parameters

vpn_service — the value can be either the ID of a vpn service or a VpnService (openstack.network.v2.vpn_service.VpnService) instance.
ignore_missing — when set to False, NotFoundException (openstack.exceptions.NotFoundException) will be raised when the vpn service does not exist. When set to True, no exception will be set when attempting to delete a nonexistent vpn service.

Returns — None.

find_vpn_service(name_or_id, ignore_missing=True, **query) — find a single vpn service. Lowkey a scavenger hunt 🕵️‍♀️

Parameters

name_or_id — the name or ID of a vpn service.
ignore_missing — when set to False, NotFoundException (openstack.exceptions.NotFoundException) will be raised when the resource does not exist. When set to True, None will be returned when attempting to find a nonexistent resource.
query — any additional parameters to be passed into underlying methods. such as query filters.

Returns — one VpnService (openstack.network.v2.vpn_service.VpnService) or None.

get_vpn_service(vpn_service, *, fields=None) — get a single vpn service.

Parameters

vpn_service — the value can be the ID of a vpn service or a VpnService (openstack.network.v2.vpn_service.VpnService) instance.
fields — limit the resource fields to fetch.

Returns — one VpnService (openstack.network.v2.vpn_service.VpnService).

Raises — NotFoundException (openstack.exceptions.NotFoundException) when no resource can be found.

vpn_services(**query) — return a generator of vpn services.

Parameters

query — optional query parameters to be sent to limit the resources being returned.

Returns — a generator of vpn service objects.

update_vpn_service(vpn_service, **attrs) — update a vpn service.

Parameters

vpn_service — either the id of a vpn service or a VpnService (openstack.network.v2.vpn_service.VpnService) instance.
attrs — the attributes to update on the VPN service represented by vpn_service.

Returns — the updated vpnservice.

🌸 Extension Operations

class openstack.network.v2._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

find_extension(name_or_id, ignore_missing=True, **query) — find a single extension. Obsessed with finding things ✨

Parameters

name_or_id — the name or ID of an extension.
ignore_missing — when set to False, NotFoundException (openstack.exceptions.NotFoundException) will be raised when the resource does not exist. When set to True, None will be returned when attempting to find a nonexistent resource.
query — any additional parameters to be passed into underlying methods. such as query filters.

Returns — one Extension (openstack.network.v2.extension.Extension) or None.

extensions(**query) — return a generator of extensions.

Parameters

query — optional query parameters to be sent to limit the resources being returned. Currently no parameter is supported.

Returns — a generator of extension objects.

🦋 Service Provider Operations

class openstack.network.v2._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

service_providers(**query) — return a generator of service providers. It’s giving “provider parade” 🎀

Parameters

query — optional query parameters to be sent to limit the resources being returned.

Returns — a generator of service provider objects.

🌈 Local IP Operations

class openstack.network.v2._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

create_local_ip(**attrs) — create a new local ip from attributes. Slay 💅

Parameters

attrs — keyword arguments which will be used to create a LocalIP (openstack.network.v2.local_ip.LocalIP), comprised of the properties on the LocalIP class.

Returns — the results of local ip creation.

delete_local_ip(local_ip, ignore_missing=True, if_revision=None) — delete a local ip.

Parameters

local_ip — bestie this one's flexible: either the ID of a local ip or an actual LocalIP instance.
- ignore_missing — set it to False and you get a NotFoundException when the local ip doesn't exist, no cap. Set it to True and nothing blows up when you try to delete a nonexistent ip, it just… doesn't.
- if_revision — the revision that goes into the If-Match header of the update request, so you can do a compare-and-swap update. fancy ✨

Returns

None — that's it, that's the whole vibe.

`find_local_ip(name_or_id, ignore_missing=True, **query)`

Find a local IP 🔍

Parameters

name_or_id — the name or ID of an local IP. (yes, "an local IP", we don't gatekeep grammar here 💅)
ignore_missing — False means a NotFoundException gets raised when the resource doesn't exist. True means you get None back when you try to find a nonexistent resource. choose your fighter.
query — any extra params passed into the underlying methods, like query filters.

Returns

One LocalIP or None 🫶

`get_local_ip(local_ip, *, fields=None)`

Get a single local ip 👑

Parameters

local_ip — either the ID of a local ip or a LocalIP instance.
fields — limit the resource fields you fetch. less is more, lowkey.

Returns

One LocalIP 💖

Raises NotFoundException when no resource can be found. 😭

`local_ips(**query)`

Return a generator of local ips 🌈

Parameters

query — optional query parameters sent along to limit the resources being returned:

name: Local IP name
description: Local IP description
project_id: Owner project ID
network_id: Local IP network
local_port_id: Local port ID
local_ip_address: The IP address of a Local IP
ip_mode: The Local IP mode

Returns

A generator of local ip objects.

`update_local_ip(local_ip, if_revision=None, **attrs)`

Update a local ip ✨

Parameters

local_ip — either the id of a local ip or a LocalIP instance.
if_revision — revision to put in the If-Match header of the update request, for that compare-and-swap update energy.
attrs — the attributes to update on the ip represented by value.

Returns

The updated ip 🔥

`create_local_ip_association(local_ip, **attrs)`

Create a new local ip association from attributes 🎀

Parameters

local_ip — the value can be the ID of a Local IP or a LocalIP instance.
attrs — keyword arguments used to create a LocalIPAssociation, comprised of the properties on the LocalIP class.

Returns

The results of local ip association creation. it's giving new resource 🦋

`delete_local_ip_association(local_ip, fixed_port_id, ignore_missing=True, if_revision=None)`

Delete a local ip association 💀

Parameters

local_ip — the value can be the ID of a Local IP or a LocalIP instance.
fixed_port_id — either the fixed port ID or a LocalIPAssociation instance (the docs literally say :class:~openstack.network.v2.local_ip_association.LocalIPAssociation and we respect it).
ignore_missing — set to False and a NotFoundException gets raised when the local ip association doesn't exist. set to True and no exception gets set when you attempt to delete a nonexistent ip.
if_revision — revision to put in the If-Match header of the update request, for the compare-and-swap update.

Returns

None 🙈

`find_local_ip_association(name_or_id, local_ip, ignore_missing=True, **query)`

Find a local ip association 🔍

Parameters

name_or_id — the name or ID of local ip association. (two spaces in the original, iconic)
local_ip — the ID of a Local IP or a LocalIP instance.
ignore_missing — False raises NotFoundException when the resource doesn't exist. True returns None when you're hunting a nonexistent resource.
query — any additional parameters passed into underlying methods, such as query filters.

Returns

One LocalIPAssociation or None. 💖

`get_local_ip_association(local_ip_association, local_ip, *, fields=None)`

Get a single local ip association 👑

Parameters

local_ip — the ID of a Local IP or a LocalIP instance.
local_ip_association — the ID of a local ip association or a LocalIPAssociation instance.
fields — limit the resource fields to fetch.

Returns

One LocalIPAssociation ✨

Raises NotFoundException when no resource can be found. 😭

`local_ip_associations(local_ip, **query)`

Return a generator of local ip associations 🌈

Parameters

local_ip — the ID of a Local IP or a LocalIP instance.
query — optional query parameters sent to limit the resources being returned:
- fixed_port_id: The ID of the port to which a local IP is associated
- fixed_ip: The fixed ip address associated with a a Local IP (the double "a a" is canon, we stan)
- host: Host where local ip is associated

Returns

A generator of local ip association objects LocalIPAssociation. 🫶

🌸 Ndp Proxy Operations 🌸

okay so this whole section is the proxy class, and it's a lot. here's the signature in full, exactly as it appears, do not come for me:

class openstack.network.v2._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

like, look at all those kwargs. main character energy fr fr 👑

`create_ndp_proxy(**attrs)`

Create a new ndp proxy from attributes 🦋

Parameters

attrs — keyword arguments which will be used to create a NDPProxxy, comprised of the properties on the NDPProxy class. (yes, NDPProxxy with two x's — that's what the page says, and we do not edit the source, bestie 💅)

Returns

The results of ndp proxy creation. 🔥

`get_ndp_proxy(ndp_proxy, *, fields=None)`

Get a single ndp proxy 👑

Parameters

ndp_proxy — the value can be the ID of a ndp proxy or a NDPProxy instance.
fields — limit the resource fields to fetch.

Returns

One NDPProxy ✨

Raises NotFoundException when no resource can be found. 😭

`find_ndp_proxy(ndp_proxy_id, ignore_missing=True, **query)`

Find a single ndp proxy 🔍

Parameters

ndp_proxy_id — the ID of a ndp proxy.
ignore_missing — when set to False, NotFoundException (openstack.exceptions.NotFoundException) gets raised if the resource doesn’t exist. When it’s True, you get None back when you try to find a nonexistent resource. Bestie, it’s the chill setting 💅
- query — any extra parameters passed into the underlying methods, like query filters.
- Returns: One NDPProxy (openstack.network.v2.ndp_proxy.NDPProxy) or None
delete_ndp_proxy(ndp_proxy, ignore_missing=True) — delete a ndp proxy ✨
- ndp_proxy — the value can be the ID of a ndp proxy or an NDPProxy (openstack.network.v2.ndp_proxy.NDPProxy) instance.
- ignore_missing — when set to False, NotFoundException (openstack.exceptions.NotFoundException) will be raised when the router does not exist. When set to True, no exception will be set when attempting to delete a nonexistent ndp proxy.
- Returns: None
ndp_proxies(**query) — return a generator of ndp proxies 🦋
- query — optional query parameters sent to limit the resources being returned. Valid parameters are:
  - router_id — the ID of the router
  - port_id — the ID of internal port.
  - ip_address — the internal IP address
- Returns: A generator of port forwarding objects
update_ndp_proxy(ndp_proxy, **attrs) — update a ndp proxy 🎀
- ndp_proxy — the value can be the ID of a ndp proxy or an NDPProxy (openstack.network.v2.ndp_proxy.NDPProxy) instance.
- attrs — the attributes to update on the ip represented by value.
- Returns: The updated ndp_proxy

🦋 BGP Operations 🦋

class openstack.network.v2._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

create_bgp_peer(**attrs) — create a new BGP Peer from attributes ✨
delete_bgp_peer(peer, ignore_missing=True) — delete a BGP Peer
find_bgp_peer(name_or_id, ignore_missing=True, **query) — find a single BGP Peer
get_bgp_peer(peer) — get a single BGP Peer
update_bgp_peer(peer, **attrs) — update a BGP Peer
bgp_peers(**query) — return a generator of BGP Peers
create_bgp_speaker(**attrs) — create a new BGP Speaker 💖
delete_bgp_speaker(speaker, ignore_missing=True) — delete a BGP Speaker
find_bgp_speaker(name_or_id, ignore_missing=True, **query) — find a single BGP Peer (yes, the source says Peer here, not Speaker — not me, bestie 🙈)
get_bgp_speaker(speaker) — get a single BGP Speaker
update_bgp_speaker(speaker, **attrs) — update a BGP Speaker
bgp_speakers(**query) — return a generator of BGP Peers (source wording again 👀)
add_bgp_peer_to_speaker(speaker, peer) — bind the BGP peer to the specified BGP Speaker.
remove_bgp_peer_from_speaker(speaker, peer) — unbind the BGP peer from a BGP Speaker.
add_gateway_network_to_speaker(speaker, network) — add a network to the specified BGP speaker.
remove_gateway_network_from_speaker(speaker, network) — remove a network from the specified BGP speaker.
get_advertised_routes_of_speaker(speaker) — list all routes advertised by the specified BGP Speaker.
get_bgp_dragents_hosting_speaker(speaker) — list all BGP dynamic agents which are hosting the specified BGP Speaker.
add_bgp_speaker_to_dragent(bgp_agent, bgp_speaker) — add a BGP Speaker to the specified dynamic routing agent.
get_bgp_speakers_hosted_by_dragent(bgp_agent) — list all BGP Speakers hosted on the specified dynamic routing agent.
remove_bgp_speaker_from_dragent(bgp_agent, bgp_speaker) — delete the BGP Speaker hosted by the specified dynamic routing agent.

🌸 Tap As A Service Operations 🌸

class openstack.network.v2._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

create_tap_flow(**attrs) — create a new Tap Flow from attributes ✨
delete_tap_flow(tap_flow, ignore_missing=True) — delete a Tap Flow
find_tap_flow(name_or_id, ignore_missing=True, **query) — find a single Tap Service (source says Service for the flow finder, iconic 💀)
get_tap_flow(tap_flow, *, fields=None) — get a single Tap Flow 🫶
- tap_flow — the value can be the ID of a tap flow or a TapFlow (openstack.network.v2.tap_flow.TapFlow) instance.
- fields — limit the resource fields to fetch.
- Returns: One TapFlow (openstack.network.v2.tap_flow.TapFlow)
- Raises: NotFoundException (openstack.exceptions.NotFoundException) when no resource can be found.
update_tap_flow(tap_flow, **attrs) — update a Tap Flow
tap_flows(**query) — return a generator of Tap Flows
create_tap_service(**attrs) — create a new Tap Service from attributes 💖
delete_tap_service(tap_service, ignore_missing=True) — delete a Tap Service
find_tap_service(name_or_id, ignore_missing=True, **query) — find a single Tap Service
update_tap_service(tap_service, **attrs) — update a Tap Service
tap_services(**query) — return a generator of Tap Services

💅 BGPVPN operations 💅

class openstack.network.v2._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

create_bgpvpn(**attrs) — create a new BGPVPN 🌈
- attrs — keyword arguments which will be used to create a BgpVpn (openstack.network.v2.bgpvpn.BgpVpn), comprised of the properties on the BGPVPN class. For details, see the Neutron api-ref.
- Returns: The result of BGPVPN creation
delete_bgpvpn(bgpvpn, ignore_missing=True) — delete a BGPVPN
- bgpvpn — the value can be either the ID of a bgpvpn or a BgpVpn (openstack.network.v2.bgpvpn.BgpVpn) instance.
- ignore_missing — when set to False, NotFoundException (openstack.exceptions.NotFoundException) will be raised when the BGPVPN does not exist. When set to True, no exception will be set when attempting to delete a nonexistent BGPVPN.
- Returns: None
find_bgpvpn(name_or_id, ignore_missing=True, **query) — find a single BGPVPN 🔍
- name_or_id — the name or ID of a BGPVPN.
- ignore_missing — when set to False, NotFoundException (openstack.exceptions.NotFoundException) will be raised when the resource does not exist. When set to True, None will be returned when attempting to find a nonexistent resource.
- query — any additional parameters to be passed into underlying methods, such as query filters.
- Returns: One BGPVPN or None
get_bgpvpn(bgpvpn, *, fields=None) — get a single BGPVPN 👑
- bgpvpn — the value can be the ID of a BGPVPN or a BgpVpn (openstack.network.v2.bgpvpn.BgpVpn) instance.
- fields — limit the resource fields to fetch.

Returns — one BgpVpn <#openstack.network.v2.bgpvpn.BgpVpn> object, bestie. ✨

Raises — NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found. Like, if it's not there, it's not there. 💀

`update_bgpvpn(bgpvpn, **attrs)`

Update a BGPVPN. Glow-up szn. 💅

Parameters

bgpvpn — either the ID of a BGPVPN or a BgpVpn <#openstack.network.v2.bgpvpn.BgpVpn> instance.
attrs — the attributes to update on the BGPVPN represented by value.

Returns — the updated BGPVPN. 👑

`bgpvpns(**query)`

Return a generator of BGP VPNs. Not a list, a generator, okay? she yields.

Parameters

query — optional query parameters to be sent to limit the resources being returned.

Returns — a generator of BgpVpn objects.

`create_bgpvpn_network_association(bgpvpn, **attrs)`

Create a new BGPVPN Network Association. new friend unlocked 🫶

Parameters

bgpvpn — the value can be either the ID of a bgpvpn or a BgpVpn <#openstack.network.v2.bgpvpn.BgpVpn> instance.
attrs — keyword arguments which will be used to create a BgpVpnNetworkAssociation, comprised of the properties on the BgpVpnNetworkAssociation class.

Returns — the results of BgpVpnNetworkAssociation creation.

`delete_bgpvpn_network_association(bgpvpn, net_association, ignore_missing=True)`

Delete a BGPVPN Network Association. it's giving closure 🌸

Parameters

bgpvpn — the value can be either the ID of a bgpvpn or a BgpVpn <#openstack.network.v2.bgpvpn.BgpVpn> instance.
net_association — the value can be either the ID of a bgpvpn_network_association or a BgpVpnNetworkAssociation instance.
ignore_missing — when set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the BgpVpnNetworkAssociation does not exist. When set to True, no exception will be set when attempting to delete a nonexistent BgpVpnNetworkAssociation.

Returns — None.

`get_bgpvpn_network_association(bgpvpn, net_association, *, fields=None)`

Get a signle BGPVPN Network Association. (yes, "signle", the docs said what they said, we respect the typo 😭)

Parameters

bgpvpn — the value can be the ID of a BGPVPN or a BgpVpn <#openstack.network.v2.bgpvpn.BgpVpn> instance.
net_association — the value can be the ID of a BgpVpnNetworkAssociation or a BgpVpnNetworkAssociation instance.
fields — limit the resource fields to fetch. only the cute parts ✨

Returns — one BgpVpnNetworkAssociation.

Raises — NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found.

`bgpvpn_network_associations(bgpvpn, **query)`

Return a generator of BGP VPN Network Associations.

Param bgpvpn: the value can be the ID of a BGPVPN or a BgpVpn <#openstack.network.v2.bgpvpn.BgpVpn> instance.

Parameters

query — optional query parameters to be sent to limit the resources being returned.

Returns — a generator of BgpVpnNetworkAssociation objects.

`create_bgpvpn_port_association(bgpvpn, **attrs)`

Create a new BGPVPN Port Association. another one, we love to see it 🎀

Parameters

bgpvpn — the value can be either the ID of a bgpvpn or a BgpVpn <#openstack.network.v2.bgpvpn.BgpVpn> instance.
attrs — keyword arguments which will be used to create a BgpVpnPortAssociation, comprised of the properties on the BgpVpnPortAssociation class.

Returns — the results of BgpVpnPortAssociation creation.

`delete_bgpvpn_port_association(bgpvpn, port_association, ignore_missing=True)`

Delete a BGPVPN Port Association. bye bestie 👋

Parameters

bgpvpn — the value can be either the ID of a bgpvpn or a BgpVpn <#openstack.network.v2.bgpvpn.BgpVpn> instance.
port_association — the value can be either the ID of a bgpvpn_port_association or a BgpVpnPortAssociation instance.
ignore_missing — when set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the BgpVpnPortAssociation does not exist. When set to True, no exception will be set when attempting to delete a nonexistent BgpVpnPortAssociation.

Returns — None.

`find_bgpvpn_port_association(name_or_id, bgpvpn_id, ignore_missing=True, **query)`

Find a single BGPVPN Port Association. detective mode 🔍

Parameters

name_or_id — the name or ID of a BgpVpnNetworkAssociation.
bgpvpn_id — the value can be the ID of a BGPVPN.
ignore_missing — when set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the resource does not exist. When set to True, None will be returned when attempting to find a nonexistent resource.
query — any additional parameters to be passed into underlying methods. such as query filters.

Returns — one BGPVPN or None.

`get_bgpvpn_port_association(bgpvpn, port_association, *, fields=None)`

Get a signle BGPVPN Port Association. (again with the "signle" — iconic typo, no notes 💀)

Parameters

bgpvpn — the value can be the ID of a BGPVPN or a BgpVpn <#openstack.network.v2.bgpvpn.BgpVpn> instance.
port_association — the value can be the ID of a BgpVpnPortAssociation or a BgpVpnPortAssociation instance.
fields — limit the resource fields to fetch.

Returns — one BgpVpnPortAssociation.

Raises — NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found.

`update_bgpvpn_port_association(bgpvpn, port_association, **attrs)`

Update a BPGPN Port Association. (yes, "BPGPN" — original spelling, we keep it fr fr 🙈)

Parameters

bgpvpn — either the ID of a BGPVPN or a BgpVpn <#openstack.network.v2.bgpvpn.BgpVpn> instance.
port_association — the value can be the ID of a BgpVpnPortAssociation or a BgpVpnPortAssociation instance.
attrs — the attributes to update on the BGPVPN represented by value.

Returns — the updated BgpVpnPortAssociation.

`bgpvpn_port_associations(bgpvpn, **query)`

Return a generator of BGP VPN Port Associations.

Param bgpvpn: the value can be the ID of a BGPVPN or a BgpVpn <#openstack.network.v2.bgpvpn.BgpVpn> instance.

Parameters

query — optional query parameters to be sent to limit the resources being returned.

Returns — a generator of BgpVpnNetworkAssociation objects. (yes it says BgpVpnNetworkAssociation in the Port one too — that's what the page says, so that's what you get 🫶)

`create_bgpvpn_router_association(bgpvpn, **attrs)`

Create a new BGPVPN Router Association. routers need love too 🌈

Parameters

bgpvpn — the value can be either the ID of a bgpvpn or a BgpVpn <#openstack.network.v2.bgpvpn.BgpVpn> instance.
attrs — keyword arguments which will be used to create a BgpVpnRouterAssociation, comprised of the properties on the BgpVpnRouterAssociation class.

Returns — the results of BgpVpnRouterAssociation creation.

`delete_bgpvpn_router_association(bgpvpn, router_association, ignore_missing=True)`

Delete a BGPVPN Router Association. closing the group chat 💅

Parameters

bgpvpn — the value can be either the ID of a bgpvpn or a BgpVpn <#openstack.network.v2.bgpvpn.BgpVpn> instance.
router_association — the value can be either the ID of a bgpvpn_router_association or a BgpVpnRouterAssociation instance.
ignore_missing — when set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the BgpVpnRouterAssociation does not exist. When set to True, no exception will be set when attempting to delete a nonexistent BgpVpnRouterAsociation. (yup, BgpVpnRouterAsociation — one "s", lowercase "soc"... we're just quoting the source, don't come for me 😭)

Returns — None.

`get_bgpvpn_router_association(bgpvpn, router_association, *, fields=None)`

Get a signle BGPVPN Router Association. third "signle" of the day, it's a tradition at this point ✨

Parameters

bgpvpn — the value can be the ID of a BGPVPN or a BgpVpn <#openstack.network.v2.bgpvpn.BgpVpn> instance.
router_association — the value can be the ID of a BgpVpnRouterAssociation or a BgpVpnRouterAssociation instance. 🫶
- fields — limit the resource fields to fetch. Only grab what you asked for, no extra luggage bestie.

Returns — one BgpVpnRouterAssociation. Just the one. A single.

Raises NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found. 💀

update_bgpvpn_router_association(bgpvpn, router_association, **attrs)

Update a BPGPN Router Association. (Yes, we know — the docstring says "BPGPN". We're not fixing it, we're respecting it. Character for character, bestie. 💅)

Parameters

query — optional query parameters to be sent to limit the resources being returned.

Returns

A generator of BgpVpnNetworkAssociation objects.

Okay so yes, this Returns line says Network Association for a method about Router Associations, and it says "generator" for a method that updates. That's what the page says, so that's what you get. Do not come for me, come for the docstring. 🙈 Not my words, not my problem.

bgpvpn_router_associations(bgpvpn, **query)

Return a generator of BGP VPN router Associations. All of them. A whole little stream of them, served up fresh. ✨

Param bgpvpn: The value can be the ID of a BGPVPN or a BgpVpn <#openstack.network.v2.bgpvpn.BgpVpn> instance.

Parameters

query — optional query parameters to be sent to limit the resources being returned.

Returns

A generator of BgpVpnRouterAssociation objects.

🦋 SFC operations 🦋


class openstack.network.v2._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

ik that signature is giving "final boss of keyword arguments" 😭 but here she is, all of it, no cap. The Proxy class lives at openstack.network.v2._proxy.Proxy and she takes a session plus that whole buffet of keyword-only config. Go off, honestly. 👑

create_sfc_flow_classifier(**attrs)

Create a new Flow Classifier from attributes. Fresh out the box, custom-built, your very own. 🎀

Parameters

attrs — keyword arguments which will be used to create a SfcFlowClassifier <#openstack.network.v2.sfc_flow_classifier.SfcFlowClassifier>, comprised of the properties on the SfcFlowClassifier class.

Returns

The results of SFC Flow Classifier creation.

delete_sfc_flow_classifier(flow_classifier, ignore_missing=True)

Delete a Flow Classifier. Gone. Poof. 💨

Parameters

flow_classifier — the value can be either the ID of a flow classifier or a SfcFlowClassifier <#openstack.network.v2.sfc_flow_classifier.SfcFlowClassifier> instance.
ignore_missing — when set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the flow classifier does not exist. When set to True, no exception will be set when attempting to delete a nonexistent flow classifier.

Note the double space in "when the flow classifier does not exist" — that's the original's double space, preserved with love. 🫶

Returns

None. Nothing. That's the whole vibe.

find_sfc_flow_classifier(name_or_id, ignore_missing=True, **query)

Find a single Flow Classifier. Detective mode: activated. 🔎

Parameters

name_or_id — the name or ID of an SFC flow classifier.
ignore_missing — when set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the resource does not exist. When set to True, None will be returned when attempting to find a nonexistent resource.
query — any additional parameters to be passed into underlying methods. such as query filters.

Returns

One SfcFlowClassifier or None. Found it or didn't, no drama either way. 🦋

get_sfc_flow_classifier(flow_classifier)

Get a single Flow Classifier. Just the one, hand-delivered. 💖

Parameters

flow_classifier — the value can be the ID of an SFC flow classifier or a SfcFlowClassifier <#openstack.network.v2.sfc_flow_classifier.SfcFlowClassifier> instance.

Returns

SfcFlowClassifier <#openstack.network.v2.sfc_flow_classifier.SfcFlowClassifier>

Raises NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found.

update_sfc_flow_classifier(flow_classifier, **attrs)

Update a Flow Classifier. Glow-up time. ✨

Parameters

flow_classifier — the value can be the ID of a Flow Classifier SfcFlowClassifier <#openstack.network.v2.sfc_flow_classifier.SfcFlowClassifier>, instance.
attrs — the attributes to update on the Flow Classifier.

Returns

The updated Flow Classifier.

create_sfc_port_chain(**attrs)

Create a new Port Chain from attributes. Link by link, bestie. ⛓️

Parameters

attrs — keyword arguments which will be used to create a SfcPortChain <#openstack.network.v2.sfc_port_chain.SfcPortChain>, comprised of the properties on the SfcPortchain class.

Returns

The results of SFC Port Chain creation.

delete_sfc_port_chain(port_chain, ignore_missing=True)

Delete a Port Chain. Breaking the chain, respectfully. 💀

Parameters

port_chain — the value can be either the ID of a port chain or a SfcPortChain <#openstack.network.v2.sfc_port_chain.SfcPortChain> instance.
ignore_missing — when set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the port chain does not exist. When set to True, no exception will be set when attempting to delete a nonexistent port chain.

Returns

None

find_sfc_port_chain(name_or_id, ignore_missing=True, **query)

Find a single Port Chain.

Parameters

name_or_id — the name or ID of an SFC port chain.
ignore_missing — when set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the resource does not exist. When set to True, None will be returned when attempting to find a nonexistent resource.
query — any additional parameters to be passed into underlying methods. such as query filters.

Returns

One SfcPortChain or None. 🌸

get_sfc_port_chain(port_chain)

Get a signle Port Chain.

"signle" — nope, that's not a typo I made, that's the page's own spelling and I'm keeping it fr fr. 😭 Original text is sacred. 🫶

Parameters

port_chain — the value can be the ID of an SFC port chain or a SfcPortChain <#openstack.network.v2.sfc_port_chain.SfcPortChain> instance.

Returns

SfcPortchain

Raises NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found.

update_sfc_port_chain(port_chain, **attrs)

Update a Port Chain. New chain, who dis. 🔥

Parameters

port_chain — the value can be the ID of a Port Chain SfcPortChain <#openstack.network.v2.sfc_port_chain.SfcPortChain>, instance.
attrs — the attributes to update on the Port Chain.

Returns

The updated Port Chain.

create_sfc_port_pair(**attrs)

Create a new Port Pair from attributes. Two ports, one pair, iconic duo energy. 👯

Parameters

attrs — keyword arguments which will be used to create a SfcPortPair <#openstack.network.v2.sfc_port_pair.SfcPortPair>, comprised of the properties on the SfcPortPair class.

Returns

The results of SFC Port Pair creation.

delete_sfc_port_pair(port_pair, ignore_missing=True)

Delete a Port Pair. Separating the duo. Sad but necessary. 😭

Parameters

port_pair — the value can be either the ID of a port pair or a SfcPortPair <#openstack.network.v2.sfc_port_pair.SfcPortPair> instance.
ignore_missing — when set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the port pair does not exist. When set to True, no exception will be set when attempting to delete a nonexistent port pair.

Returns

None

find_sfc_port_pair(name_or_id, ignore_missing=True, **query)

Find a single Port Pair. 🍓

Parameters

name_or_id — the name or ID of an SFC port pair.
ignore_missing — when set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the resource does not exist. When set to True, None will be returned when attempting to find a nonexistent resource.
query — any additional parameters to be passed into underlying methods. such as query filters.
get_sfc_port_pair(port_pair) — Get a signle Port Pair 💅

Parameters

port_pair — The value can be the ID of an SFC port pair or a SfcPortPair <#openstack.network.v2.sfc_port_pair.SfcPortPair> instance.

Returns

SfcPortPair <#openstack.network.v2.sfc_port_pair.SfcPortPair>

Raises NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found. 😭

update_sfc_port_pair(port_pair, **attrs) — Update a Port Pair ✨

Parameters

port_pair — The value can be the ID of a Port Pair SfcPortPair <#openstack.network.v2.sfc_port_pair.SfcPortPair>, instance.
attrs — The attributes to update on the Port Pair

Returns

The updated Port Pair. 🫶

create_sfc_port_pair_group(**attrs) — Create a new Port Pair Group from attributes 🌸

Parameters

attrs — Keyword arguments which will be used to create a SfcPortPairGroup <#openstack.network.v2.sfc_port_pair_group.SfcPortPairGroup>, comprised of the properties on the SfcPortPairGroup class.

Returns

The results of SFC Port Pair Group creation 🎀

delete_sfc_port_pair_group(port_pair_group, ignore_missing=True) — Delete a Port Pair Group 💀

Parameters

port_pair_group — The value can be either the ID of a port pair group or a SfcPortPairGroup instance.
ignore_missing — When set to False NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the port pair group does not exist. When set to True, no exception will be set when attempting to delete a nonexistent port pair group.

Returns

None

find_sfc_port_pair_group(name_or_id, ignore_missing=True, **query) — Find a single Port Pair Group 🔍

Parameters

name_or_id — The name or ID of an SFC port pair group.
ignore_missing — When set to False NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the resource does not exist. When set to True, None will be returned when attempting to find a nonexistent resource.
query — Any additional parameters to be passed into underlying methods. such as query filters.

Returns

One SfcPortPairGroup or None

get_sfc_port_pair_group(port_pair_group) — Get a signle Port Pair Group 💅

Parameters

port_pair_group — The value can be the ID of an SFC port pair group or a SfcPortPairGroup <#openstack.network.v2.sfc_port_pair_group.SfcPortPairGroup> instance.

Returns

SfcPortPairGroup <#openstack.network.v2.sfc_port_pair_group.SfcPortPairGroup>

Raises NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found. 😭

update_sfc_port_pair_group(port_pair_group, **attrs) — Update a Port Pair Group ✨

Parameters

port_pair_group — The value can be the ID of a Port Pair Group SfcPortPairGroup <#openstack.network.v2.sfc_port_pair_group.SfcPortPairGroup>, instance.
attrs — The attributes to update on the Port Pair Group

Returns

The updated Port Pair Group. 🫶

create_sfc_service_graph(**attrs) — Create a new Service Graph from attributes 🌈

Parameters

attrs — Keyword arguments which will be used to create a SfcServiceGraph <#openstack.network.v2.sfc_service_graph.SfcServiceGraph>, comprised of the properties on the SfcServiceGraph class.

Returns

The results of SFC Service Graph creation 🎀

delete_sfc_service_graph(service_graph, ignore_missing=True) — Delete a Service Graph 💀

Parameters

service_graph — The value can be either the ID of a service graph or a SfcServiceGraph <#openstack.network.v2.sfc_service_graph.SfcServiceGraph> instance.
ignore_missing — When set to False NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the service graph does not exist. When set to True, no exception will be set when attempting to delete a nonexistent service graph.

Returns

None

find_sfc_service_graph(name_or_id, ignore_missing=True, **query) — Find a single Service Graph 🔍

Parameters

name_or_id — The name or ID of an SFC service graph.
ignore_missing — When set to False NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the resource does not exist. When set to True, None will be returned when attempting to find a nonexistent resource.
query — Any additional parameters to be passed into underlying methods. such as query filters.

Returns

One SfcServiceGraph or None

get_sfc_service_graph(service_graph) — Get a signle Service Graph 💅

Parameters

service_graph — The value can be the ID of an SFC service graph or a SfcServiceGraph <#openstack.network.v2.sfc_service_graph.SfcServiceGraph> instance.

Returns

SfcServiceGraph <#openstack.network.v2.sfc_service_graph.SfcServiceGraph>

Raises NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found. 😭

update_sfc_service_graph(service_graph, **attrs) — Update a Service Graph ✨

Parameters

service_graph — The value can be the ID of a Service Graph SfcServiceGraph <#openstack.network.v2.sfc_service_graph.SfcServiceGraph>, instance.
attrs — The attributes to update on the Service Graph

Returns

The updated Service Graph. 🫶

🦋 Tap Mirror operations

okay so the whole tap mirror situation lives on this proxy class, and here's literally the entire signature bestie, don't skip a single keyword-only arg, iykyk:

class openstack.network.v2._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

create_tap_mirror(**attrs) — Create a new Tap Mirror from attributes ✨
delete_tap_mirror(tap_mirror, ignore_missing=True) — Delete a Tap Mirror 💀
find_tap_mirror(name_or_id, ignore_missing=True, **query) — Find a single Tap Mirror 🔍
get_tap_mirror(tap_mirror, *, fields=None) — Get a signle Tap Mirror 💅

Parameters

tap_mirror — The value can be the ID of a tap mirror or a TapMirror <#openstack.network.v2.tap_mirror.TapMirror> instance.
fields — Limit the resource fields to fetch.

Returns

One TapMirror <#openstack.network.v2.tap_mirror.TapMirror>

Raises NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found. 😭

update_tap_mirror(tap_mirror, **attrs) — Update a Tap Mirror ✨
tap_mirrors(**query) — Return a generator of Tap Mirrors 🌈

🛒 Object Store API

For details on how to use this API, see Using OpenStack Object Store <>

🎀 The Object Store Class

The Object Store high-level interface is exposed as the object_store object on Connection <#openstack.connection.Connection> objects. literally so convenient, you just reach for it and it's there 💖

🍓 Account Operations

here's the class for the account ops, full signature, no cap:

class openstack.object_store.v1._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

`get_account_metadata()`

Get the metadata for this account. That's it, that's the vibe ✨

`set_account_metadata(**metadata)`

Set metadata for this account. 🎀

Parameters

metadata — Key/value pairs to be set as metadata on the container. Custom metadata can be set. Custom metadata are keys and values defined by the user.

`delete_account_metadata(keys)`

Delete metadata for this account. Bye-bye 👋

Parameters

keys — The keys of metadata to be deleted.

🧺 Container Operations 🧺

Okay bestie, this is where it gets good. Same Proxy class, same energy:

class openstack.object_store.v1._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

`containers(**query)`

Obtain Container objects for this account. Like, all of them. 💅

Parameters

query — Optional query parameters to be sent to limit the resources being returned.

`create_container(name, **attrs)`

Create a new container from attributes 🌸

Parameters

container — Name of the container to create.
attrs — Keyword arguments which will be used to create a Container <#openstack.object_store.v1.container.Container>, comprised of the properties on the Container class.

Returns

The results of container creation.

`delete_container(container, ignore_missing=True)`

Delete a container. Gone. Reduced to atoms 💀

Parameters

container — The value can be either the name of a container or a Container <#openstack.object_store.v1.container.Container> instance.
ignore_missing — When set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the container does not exist. When set to True, no exception will be set when attempting to delete a nonexistent server.

Returns

None

`get_container_metadata(container)`

Get metadata for a container 🔍

Parameters

container — The value can be the name of a container or a Container <#openstack.object_store.v1.container.Container> instance.

Returns

One Container <#openstack.object_store.v1.container.Container>.

Raises NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found.

`set_container_metadata(container, refresh=True, **metadata)`

Set metadata for a container. Iconic behaviour honestly 👑

Parameters

container — The value can be the name of a container or a Container <#openstack.object_store.v1.container.Container> instance.
refresh — Flag to trigger refresh of container object re-fetch.
metadata — Key/value pairs to be set as metadata on the container. Both custom and system metadata can be set. Custom metadata are keys and values defined by the user. System metadata are keys defined by the Object Store and values defined by the user. The system metadata keys are:
- content_type
- is_content_type_detected
- versions_location
- read_ACL
- write_ACL
- sync_to
- sync_key

`delete_container_metadata(container, keys)`

Delete metadata for a container. Clearing out the vibes 🧹

Parameters

container — The value can be the ID of a container or a Container <#openstack.object_store.v1.container.Container> instance.
keys — The keys of metadata to be deleted.

🦋 Object Operations 🦋

Bestie we are so close. Same class, third time's the charm:

class openstack.object_store.v1._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

`objects(container, **query)`

Return a generator that yields the Container's objects. It's giving "infinite scroll but make it cloud storage" 😌

Parameters

container — A container object or the name of a container that you want to retrieve objects from.
query — Optional query parameters to be sent to limit the resources being returned.

`get_object(obj, container=None, resp_chunk_size=1024, outfile=None, remember_content=False)`

Get the data associated with an object. The main character of this whole section, lowkey 🫶

Parameters

obj — The value can be the name of an object or a Object <#openstack.object_store.v1.obj.Object> instance.
container — The value can be the name of a container or a Container <#openstack.object_store.v1.container.Container> instance.
resp_chunk_size — chunk size of data to read. Only used if the results are being written to a file or stream is True. (optional, defaults to 1k)
outfile — Write the object to a file instead of returning the contents. If this option is given, body in the return tuple will be None. outfile can either be a file path given as a string, or a File like object.
remember_content — Flag whether object data should be saved as data property of the Object. When left as false and outfile is not defined data will not be saved and need to be fetched separately.

Returns

Instance of the Object <#openstack.object_store.v1.obj.Object> objects.

Raises NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found.

`download_object(obj, container=None, **attrs)`

Download the data contained inside an object. Snatch it, bestie 💖

Parameters

obj — The value can be the name of an object or a Object <#openstack.object_store.v1.obj.Object> instance.
container — The value can be the name of a container or a Container <#openstack.object_store.v1.container.Container> instance.

Raises NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found.

`upload_object(container, name, filename=None, md5=None, sha256=None, segment_size=None, use_slo=True, metadata=None, generate_checksums=None, data=None, **headers)`

Create a file object. Automatically uses large-object segments if needed — like she does the most, effortlessly ✨

Parameters

container — The name of the container to store the file in. This container will be created if it does not exist already.
name — Name for the object within the container.
filename — The path to the local file whose contents will be uploaded. Mutually exclusive with data.
data — The content to upload to the object. Mutually exclusive with filename.
md5 — A hexadecimal md5 of the file. (Optional), if it is known and can be passed here, it will save repeating the expensive md5 process. It is assumed to be accurate.
sha256 — A hexadecimal sha256 of the file. (Optional) See md5.
segment_size — Break the uploaded object into segments of this many bytes. (Optional) SDK will attempt to discover the maximum value for this from the server if it is not specified, or will use a reasonable default.
headers — These will be passed through to the object creation API as HTTP Headers.
use_slo — If the object is large enough to need to be a Large Object, use a static rather than dynamic object. Static Objects will delete segment objects when the manifest object is deleted. (optional, defaults to True)

heads up fr: filename and data are mutually exclusive — pick one, don't do both 🙈

generate_checksums — Whether to generate checksums on the client side that get added to headers for later prevention of double uploads of identical data. (optional, defaults to True)
metadata — This dict will get changed into headers that set metadata of the object

Raises SDKException (openstack.exceptions.SDKException) on operation error.

`copy_object()`

Copy an object. Literally just copy it, bestie. Slay.

`delete_object(obj, ignore_missing=True, container=None)`

Delete an object. Yeet.

obj — The value can be either the name of an object or a Container <#openstack.object_store.v1.container.Container> instance.
container — The value can be the ID of a container or a Container <#openstack.object_store.v1.container.Container> instance.
ignore_missing — When set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the object does not exist. When set to True, no exception will be set when attempting to delete a nonexistent server. (Yes, it says server — that's the original wording, no cap 😭)

Returns None

`get_object_metadata(obj, container=None)`

Get metadata for an object.

obj — The value can be the name of an object or a Object <#openstack.object_store.v1.obj.Object> instance.
container — The value can be the ID of a container or a Container <#openstack.object_store.v1.container.Container> instance.

Returns One Object <#openstack.object_store.v1.obj.Object>

Raises NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found.

`set_object_metadata(obj, container=None, **metadata)`

Set metadata for an object.

Note: This method will do an extra HEAD call.

obj — The value can be the name of an object or a Object <#openstack.object_store.v1.obj.Object> instance.
container — The value can be the name of a container or a Container <#openstack.object_store.v1.container.Container> instance.
metadata — Key/value pairs to be set as metadata on the container. Both custom and system metadata can be set. Custom metadata are keys and values defined by the user. System metadata are keys defined by the Object Store and values defined by the user. The system metadata keys are:
- content_type
- content_encoding
- content_disposition
- delete_after
- delete_at
- is_content_type_detected

`delete_object_metadata(obj, container=None, keys=None)`

Delete metadata for an object.

obj — The value can be the name of an object or a Object <#openstack.object_store.v1.obj.Object> instance.
container — The value can be the ID of a container or a Container <#openstack.object_store.v1.container.Container> instance.
keys — The keys of metadata to be deleted.

🎼 Orchestration API 🎼

For details on how to use orchestration, see Using OpenStack Orchestration <>.

The Orchestration Class

The orchestration high-level interface is available through the orchestration member of a Connection <#openstack.connection.Connection> object. The orchestration member will only be added if the service is detected.

Stack Operations

class openstack.orchestration.v1._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

`create_stack(preview=False, **attrs)`

Create a new stack from attributes.

preview — When True, a preview endpoint will be used to verify the template. Default: False
attrs — Keyword arguments which will be used to create a Stack <#openstack.orchestration.v1.stack.Stack>, comprised of the properties on the Stack class.

Returns The results of stack creation

`find_stack(name_or_id, ignore_missing=True, resolve_outputs=True)`

Find a single stack.

name_or_id — The name or ID of a stack.
ignore_missing — When set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the resource does not exist. When set to True, None will be returned when attempting to find a nonexistent resource.

Returns One Stack <#openstack.orchestration.v1.stack.Stack> or None

`stacks(**query)`

Return a generator of stacks.

query — Optional query parameters to be sent to limit the resources being returned.

Returns A generator of stack objects

`get_stack(stack, resolve_outputs=True)`

Get a single stack.

stack — The value can be the ID of a stack or a Stack <#openstack.orchestration.v1.stack.Stack> instance.
resolve_outputs — Whether stack should contain outputs resolved.

Returns One Stack <#openstack.orchestration.v1.stack.Stack>

Raises NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found.

`update_stack(stack, *, preview=False, **attrs)`

Update a stack.

stack — The value can be the ID of a stack or a Stack <#openstack.orchestration.v1.stack.Stack> instance.
attrs — The attributes to update on the stack represented by value.

Returns The updated stack

Raises NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found.

`delete_stack(stack, ignore_missing=True)`

Delete a stack.

stack — The value can be either the ID of a stack or a Stack <#openstack.orchestration.v1.stack.Stack> instance.
ignore_missing — When set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the stack does not exist. When set to True, no exception will be set when attempting to delete a nonexistent stack.

Returns None

`export_stack(stack)`

Get the stack data in JSON format.

stack — The value can be the ID or a name or an instance of Stack <#openstack.orchestration.v1.stack.Stack>

Returns A dictionary containing the stack data.

Raises NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found.

`get_stack_template(stack)`

Get template used by a stack.

stack — The value can be the ID of a stack or an instance of Stack <#openstack.orchestration.v1.stack.Stack>

Returns One object of StackTemplate <#openstack.orchestration.v1.stack_template.StackTemplate>

Raises NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found.

`get_stack_environment(stack)`

Get environment used by a stack.

stack — The value can be the ID of a stack or an instance of Stack <#openstack.orchestration.v1.stack.Stack>

Returns One object of StackEnvironment <#openstack.orchestration.v1.stack_environment.StackEnvironment>

Raises NotFoundException <#openstack.exceptions.NotFoundException> when no resource can be found.

💖 Stack Resource Operations

Okay bestie, real talk — every single one of these sections is literally the same Proxy class, so I'm not gonna make you sit through the whole constructor signature a million times. But the first time? We're doing it properly, 'cause that's the icon we're dealing with 👑

class openstack.orchestration.v1._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

Like, that's the whole glow-up list. Every kwarg. We're not skipping a single one, periodt.

`resources(stack, **query)`

✨ Returns you a generator of resources ✨ — a whole lil stream of them, one at a time, like scrolling your fyp.

Parameters:

stack — ngl this one's flexible: it can be an actual stack object, OR just the name of a stack whose resources you wanna list 🫶
query — optional query params you send along to limit which resources come back (a little filter, a little curation, we love to see it)

Returns: a generator of resource objects — but only if the stack actually exists AND has resources in it. If the stack can't be found? Exception. Immediately. No vibes. 💀

The resource objects it hands you are Resource (#openstack.orchestration.v1.resource.Resource) — that's the type, bestie.

Raises: NotFoundException (#openstack.exceptions.NotFoundException) when the stack cannot be found. Like, it's gone gone.

💅 Stack Action Operations

Same Proxy class, same constructor signature, same energy:

class openstack.orchestration.v1._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

`check_stack(stack)`

Checks a stack's status. 👀

And here's the thing — this is an asynchronous action, so there's literally no other way to check the result than to track the stack's status yourself. No instant answer, no shortcut, that's just the deal. 🌀

Parameters:

stack — either the ID of a stack, or an actual instance of Stack (#openstack.orchestration.v1.stack.Stack)

Returns: None. That's it. That's the whole return. 🙈

`suspend_stack(stack)`

Suspends a stack's status. Putting it on pause, putting it in airplane mode ✈️

Parameters:

stack — again, either the ID of a stack or an instance of Stack (#openstack.orchestration.v1.stack.Stack)

Returns: None

`resume_stack(stack)`

Resumes a stack's status — un-pausing it, bringing it back online, the comeback era 🌈

Parameters:

stack — either the ID of a stack or an instance of Stack (#openstack.orchestration.v1.stack.Stack)

Returns: None

🦋 Stack Event Operations

You guessed it — same Proxy class, same giant signature, here it is once more in all its glory:

class openstack.orchestration.v1._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

`stack_events(stack, resource_name=None, **attr)`

Gets you stack events — the receipts, the timeline, the lore 📜

Parameters:

stack — the value can be the ID of a stack or an instance of Stack (#openstack.orchestration.v1.stack.Stack)
resource_name — the name of the resource. And here's the tea: if resource_name is not None, the base_path changes. Yes, it literally switches up the path on you. Lowkey important 🚨

Returns: a generator of stack_events objects. A whole stream of them, bestie 🎀

🌸 Stack Template Operations

Same Proxy class, same constructor, same everything — one more time for the people in the back:

class openstack.orchestration.v1._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

`validate_template(template, environment=None, template_url=None, ignore_errors=None)`

Validates a template. A whole vibe check for your template, fr fr ✅

Parameters:

template — the stack template that the validation is performed on
environment — a JSON environment for the stack, if you've got one to provide
template_url — a URI to the location containing the stack template for validation. This one's only required if the template parameter is None. And heads up: this parameter gets ignored if template is specified. Pick a lane, you know? 💅
ignore_errors — a string containing comma separated error codes to ignore. Currently the only valid error code is '99001' — that's the one and only, don't try to sneak others in 🙈

Returns: the result of template validation

Raises:

InvalidRequest (#openstack.exceptions.InvalidRequest) if neither template nor template_url is provided — like, you gotta give it something
HttpException (#openstack.exceptions.HttpException) if the template fails the validation — the template did not slay, and it will be told 😭

🎀 Software Configuration Operations

Last Proxy class of this part, same iconic signature, here we go:

class openstack.orchestration.v1._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

`create_software_config(**attrs)`

Creates a brand new software config out of attributes 🌱

Parameters:

attrs — keyword arguments that'll be used to create a SoftwareConfig (#openstack.orchestration.v1.software_config.SoftwareConfig), made up of the properties on the SoftwareConfig class

Returns: the results of software config creation, as a SoftwareConfig (#openstack.orchestration.v1.software_config.SoftwareConfig)

`software_configs(**query)`

Returns a generator of software configs 🧚 — a lil stream of them

Parameters:

query — optional query parameters sent along to limit the software configs returned

Returns: a generator of software config objects, SoftwareConfig (#openstack.orchestration.v1.software_config.SoftwareConfig)

`get_software_config(software_config)`

Gets you all the details about one specific software config 🔍

Parameters:

software_config — the value can be the ID of a software config, or an instace of SoftwareConfig (#openstack.orchestration.v1.software_config.SoftwareConfig) — yes, that's how the original spells it, "instace", we're keeping it, character for character bestie 🫶

Returns: an object of type SoftwareConfig (#openstack.orchestration.v1.software_config.SoftwareConfig)

`delete_software_config(software_config, ignore_missing=True)`

Deletes a software config. Gone. Poof. 🦋

Parameters:

software_config — either the ID of a software config or an instance of SoftwareConfig (#openstack.orchestration.v1.software_config.SoftwareConfig)
ignore_missing — when set to False, NotFoundException (#openstack.exceptions.NotFoundException) gets raised when the software config doesn't exist. When set to True, no exception will be set when attempting to delete a nonexistent software config. (That's literally what the original says — "no exception will be set" — so we're keeping it exactly as-is, no editing ✨)

Returns: None

🛠️ Software Deployment Operations

okay bestie, buckle up — here's the proxy object for software deployments, and yes I'm giving you the entire constructor signature because we don't gatekeep parameters in this house 💅

class openstack.orchestration.v1._proxy.Proxy(session, *,
service_type=None, service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

every single one of those kwargs is right there — service_type, service_name, interface, region_name, endpoint_override, version, auth, user_agent, connect_retries, logger, allow, additional_headers, client_name, client_version, allow_version_hack, global_request_id, min_version, max_version, default_microversion, status_code_retries, retriable_status_codes, raise_exc, rate_limit, concurrency, connect_retry_delay, status_code_retry_delay, statsd_client, statsd_prefix, prometheus_counter, prometheus_histogram, influxdb_config, influxdb_client. iconic. no notes. ✨

🌸 `create_software_deployment(**attrs)`

make a whole new software deployment out of attributes, slay.

Parameters
- attrs — keyword arguments that get used to create a SoftwareDeployment <#openstack.orchestration.v1.software_deployment.SoftwareDeployment>, made up of the properties on the SoftwareDeployment class.
Returns — the results of software deployment creation 🫶

🌸 `software_deployments(**query)`

hands you a generator of software deployments. very demure, very lazy-evaluated.

Parameters
- query — optional query parameters that get sent along to limit the software deployments returned.
Returns — a generator of software deployment objects: SoftwareDeployment <#openstack.orchestration.v1.software_deployment.SoftwareDeployment>

🌸 `get_software_deployment(software_deployment)`

grab the deets on one specific software deployment resource 🔍

Parameters
- software_deployment — the value can be the ID of a software deployment, or an instance of SoftwareDeployment <#openstack.orchestration.v1.software_deployment.SoftwareDeployment>,
Returns — an object of type SoftwareDeployment <#openstack.orchestration.v1.software_deployment.SoftwareDeployment>

🌸 `delete_software_deployment(software_deployment, ignore_missing=True)`

bye bye software deployment 👋

Parameters
- software_deployment — the value can be either the ID of a software deployment or an instance of SoftwareDeployment <#openstack.orchestration.v1.software_deployment.SoftwareDeployment>
- ignore_missing — when set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the software deployment does not exist. When set to True, no exception will be set when attempting to delete a nonexistent software deployment.
Returns — None

🌸 `update_software_deployment(software_deployment, **attrs)`

update a software deployment, glow-up edition ✨

Parameters
- server — either the ID of a software deployment or an instance of SoftwareDeployment <#openstack.orchestration.v1.software_deployment.SoftwareDeployment>. (yes, the docs literally label this bullet server here even though the parameter in the signature is software_deployment — just reporting what's written, don't come for me 🙈)
- attrs — the attributes to update on the software deployment represented by software_deployment.
Returns — the updated software deployment

💫 Placement API

The Placement Class

the placement high-level interface is available through the placement member of a Connection <#openstack.connection.Connection> object. heads up though: the placement member will only be added if the service is detected 👑

Allocation Candidates

class openstack.placement.v1._proxy.Proxy(session, *,
service_type=None, service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

same full signature, every kwarg, absolutely no crumbs left behind 🍓

allocation_candidates(**query) — retrieve a generator of allocation candidates. each yielded AllocationCandidate <#openstack.placement.v1.allocation_candidate.AllocationCandidate> represents one candidate set of allocations, and contains:

allocations — a dict mapping resource provider UUID to the resources to request from that provider.
mappings — a dict mapping request-group suffixes to provider UUIDs (available from microversion 1.34).
provider_summaries — a dict keyed by resource provider UUID with capacity and trait information for providers in this candidate.

Parameters

query — Query parameters forwarded directly to placement. common parameters include:
- resources — a comma-separated CLASS:AMOUNT string, e.g. VCPU:1,DISK_GB:10,MEMORY_MB:512
- required — comma-separated required (or !-prefixed forbidden) traits
- member_of — aggregate UUID filter
- in_tree — restrict to a resource provider subtree
- limit — maximum number of candidates to return
- group_policy — isolate or none
- root_required — traits required on the root provider
- same_subtree — request-group suffixes that must share a tree

numbered variants (resources1, required1, member_of1, in_tree1, …) are accepted for granular request groups. iykyk 🧚

Returns — a generator of AllocationCandidate <#openstack.placement.v1.allocation_candidate.AllocationCandidate> instances.

Allocations

class openstack.placement.v1._proxy.Proxy(session, *,
service_type=None, service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

third time's the charm, same signature, still every single kwarg 💜

get_allocation(consumer) — get allocations for a consumer.

Parameters
- consumer — the UUID of the consumer, or an Allocation <#openstack.placement.v1.allocation.Allocation> instance.
Returns — an instance of Allocation <#openstack.placement.v1.allocation.Allocation> with all allocations for the given consumer.
Raises — NotFoundException <#openstack.exceptions.NotFoundException> when no allocations for the consumer could be found. 😭

update_allocation(consumer, **attrs) — set or update allocations for a consumer.

creates or replaces all allocation records for the consumer identified by consumer. and fr fr, if allocations already exist for this consumer they are replaced — not merged, not patched, replaced. 👀

Parameters
- consumer — the UUID of the consumer, or an Allocation <#openstack.placement.v1.allocation.Allocation> instance.
- attrs — keyword arguments which will be used to update the Allocation <#openstack.placement.v1.allocation.Allocation>, comprised of the properties on the Allocation class. at a minimum, allocations, project_id, and user_id must be provided when creating new allocations.
Returns — the updated Allocation <#openstack.placement.v1.allocation.Allocation>.

create_allocations(allocations) — create or update allocations for multiple consumers. multitasking queen 🌈

Parameters
- allocations — a dict keyed by consumer UUID. each value must contain allocations, project_id, user_id, and consumer_generation; from microversion 1.38 consumer_type is also required. pass an empty allocations value for a consumer to remove all of their allocations.
Returns — None
Raises — ConflictException <#openstack.exceptions.ConflictException> if any resource provider or consumer generation does not match, or if there is insufficient inventory. 💀

delete_allocation(consumer, ignore_missing=True) — delete all allocations for a consumer.

Parameters
- consumer — the UUID of the consumer, or an Allocation <#openstack.placement.v1.allocation.Allocation> instance.
ignore_missing — set it to False and a NotFoundException <#openstack.exceptions.NotFoundException> gets raised when there are literally no allocations for the consumer. Set it to True and no exception gets raised when you try to delete allocations for a consumer that has none. 🫶

Returns — None

✨ Usages ✨

class openstack.placement.v1._proxy.Proxy(session, *, service_type=None,
       service_name=None, interface=None, region_name=None,
       endpoint_override=None, version=None, auth=None, user_agent=None,
       connect_retries=None, logger=None, allow=None, additional_headers=None,
       client_name=None, client_version=None, allow_version_hack=None,
       global_request_id=None, min_version=None, max_version=None,
       default_microversion=None, status_code_retries=None,
       retriable_status_codes=None, raise_exc=None, rate_limit=None,
       concurrency=None, connect_retry_delay=None,
       status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
       prometheus_counter=None, prometheus_histogram=None,
       influxdb_config=None, influxdb_client=None)

usages(project_id, user_id=None, consumer_type=None) — gives you a generator of resource usages for a project. Each yielded Usage <#openstack.placement.v1.usage.Usage> is one consumer type and contains the total resource consumption by consumers of that type inside the given project. 💖

Parameters

project_id — the UUID of the project you're reporting usage for.
user_id — the UUID of the user to filter by even more. Optional.
consumer_type — the consumer type to filter by. Optional; requires placement microversion 1.38 or later.

Returns — a generator of Usage <#openstack.placement.v1.usage.Usage> instances.

🎀 Resource Classes 🎀

class openstack.placement.v1._proxy.Proxy(session, *, service_type=None,
       service_name=None, interface=None, region_name=None,
       endpoint_override=None, version=None, auth=None, user_agent=None,
       connect_retries=None, logger=None, allow=None, additional_headers=None,
       client_name=None, client_version=None, allow_version_hack=None,
       global_request_id=None, min_version=None, max_version=None,
       default_microversion=None, status_code_retries=None,
       retriable_status_codes=None, raise_exc=None, rate_limit=None,
       concurrency=None, connect_retry_delay=None,
       status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
       prometheus_counter=None, prometheus_histogram=None,
       influxdb_config=None, influxdb_client=None)

create_resource_class(**attrs) — creates a brand-new resource class from attributes. ✨

Parameters

attrs — keyword arguments used to create a ResourceClass <#openstack.placement.v1.resource_class.ResourceClass>, made up of the properties on the ResourceClass class.

Returns — the results of resource class creation.

delete_resource_class(resource_class, ignore_missing=True) — deletes a resource class. 💅

Parameters

resource_class — the value can be either the ID of a resource class or an ResourceClass <#openstack.placement.v1.resource_class.ResourceClass> instance.
ignore_missing — when set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the resource class does not exist. When set to True, no exception will be set when attempting to delete a nonexistent resource class.

Returns — None

update_resource_class(resource_class, **attrs) — updates a resource class. 🦋

Parameters

resource_class — the value can be either the ID of a resource class or an ResourceClass <#openstack.placement.v1.resource_class.ResourceClass> instance.
attrs — the attributes to update on the resource class represented by resource_class.

Returns — the updated resource class.

get_resource_class(resource_class) — gets a single resource_class. 🔥

Parameters

resource_class — the value can be either the ID of a resource class or an ResourceClass <#openstack.placement.v1.resource_class.ResourceClass> instance.

Returns — an instance of ResourceClass <#openstack.placement.v1.resource_class.ResourceClass>

Raises — NotFoundException <#openstack.exceptions.NotFoundException> when no resource class matching the criteria could be found.

resource_classes(**query) — retrieves a generator of resource classs. Yes, that's the word in the docs — we're keeping it, bestie 😭

Parameters

query — optional query parameters sent to restrict the resource classs to be returned.

Returns — a generator of resource class instances.

💅 Resource Providers 💅

class openstack.placement.v1._proxy.Proxy(session, *, service_type=None,
       service_name=None, interface=None, region_name=None,
       endpoint_override=None, version=None, auth=None, user_agent=None,
       connect_retries=None, logger=None, allow=None, additional_headers=None,
       client_name=None, client_version=None, allow_version_hack=None,
       global_request_id=None, min_version=None, max_version=None,
       default_microversion=None, status_code_retries=None,
       retriable_status_codes=None, raise_exc=None, rate_limit=None,
       concurrency=None, connect_retry_delay=None,
       status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
       prometheus_counter=None, prometheus_histogram=None,
       influxdb_config=None, influxdb_client=None)

create_resource_provider(**attrs) — creates a new resource provider from attributes. 🎀

Parameters

attrs — keyword arguments used to create a ResourceProvider <#openstack.placement.v1.resource_provider.ResourceProvider>, made up of the properties on the ResourceProvider class.

Returns — the results of resource provider creation.

delete_resource_provider(resource_provider, ignore_missing=True) — deletes a resource provider. ⭐

Parameters

resource_provider — the value can be either the ID of a resource provider or an ResourceProvider <#openstack.placement.v1.resource_provider.ResourceProvider> instance.
ignore_missing — when set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the resource provider does not exist. When set to True, no exception will be set when attempting to delete a nonexistent resource provider.

Returns — None

update_resource_provider(resource_provider, **attrs) — updates a resource provider. 🌸

Parameters

resource_provider — the value can be either the ID of a resource provider or an ResourceProvider <#openstack.placement.v1.resource_provider.ResourceProvider> instance.
attrs — the attributes to update on the resource provider represented by resource_provider.

Returns — the updated resource provider.

get_resource_provider(resource_provider) — gets a single resource_provider. 🔥

Parameters

resource_provider — the value can be either the ID of a resource provider or an ResourceProvider <#openstack.placement.v1.resource_provider.ResourceProvider> instance.

Returns — an instance of ResourceProvider <#openstack.placement.v1.resource_provider.ResourceProvider>

Raises — NotFoundException <#openstack.exceptions.NotFoundException> when no resource provider matching the criteria could be found.

find_resource_provider(name_or_id, ignore_missing=True) — finds a single resource_provider. 🫶

Parameters

name_or_id — the name or ID of a resource provider.
ignore_missing — when set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the resource does not exist. When set to True, None will be returned when attempting to find a nonexistent resource.

Returns — an instance of ResourceProvider <#openstack.placement.v1.resource_provider.ResourceProvider>

Raises — NotFoundException <#openstack.exceptions.NotFoundException> when no resource provider matching the criteria could be found.

resource_providers(**query) — retrieves a generator of resource providers. 💜

Parameters

query — optional query parameters sent to restrict the resource providers to be returned.

Returns — a generator of resource provider instances.

get_resource_provider_aggregates(resource_provider) — gets a list of aggregates for a resource provider. 🌈

⚠️ Deprecated since version 4.14.0: use fetch_resource_provider_aggregates() instead. 💅

Okay so set_resource_provider_aggregates(resource_provider, *aggregates) is the one that updates aggregates for a resource provider. Very “new phone who dis” energy for aggregates.

Parameters

resource_provider — the value can be either the ID of a resource provider or an ResourceProvider instance (openstack.placement.v1.resource_provider.ResourceProvider). 🫶
aggregates — a list of aggregates. Heads up bestie: these aggregates will replace all aggregates currently present. It’s a full reset, not a little touch-up. ✨

Returns

An instance of ResourceProvider (openstack.placement.v1.resource_provider.ResourceProvider) with the aggregates attribute populated with the updated value. Obsessed, honestly. 💖

Raises

NotFoundException (openstack.exceptions.NotFoundException) when no resource provider matching the criteria could be found. Rude but fair. 😭

`fetch_resource_provider_usages(resource_provider)`

Fetch usages for a specific resource provider. It’s giving “so how much are you actually using, bestie?” 🔍

Parameters

resource_provider — the value can be either the ID of a resource provider or a ResourceProvider (openstack.placement.v1.resource_provider.ResourceProvider) instance.

Returns

An instance of ResourceProvider (openstack.placement.v1.resource_provider.ResourceProvider) with the usages attribute populated. Slay. ✨

Raises

NotFoundException (openstack.exceptions.NotFoundException) when no resource provider matching the criteria could be found. 💀

💖 Resource Provider Allocations 💖

The proxy class is literally this whole mood:

class openstack.placement.v1._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

`resource_provider_allocations(resource_provider, **query)`

Retrieve a generator of resource provider allocations. Generator, not a list — keep that in mind, bestie. 🌀

Parameters

resource_provider — either the ID of a resource provider or a ResourceProvider (openstack.placement.v1.resource_provider.ResourceProvider) instance.
query — optional query parameters to be sent to limit the resources being returned.

Returns

A generator of resource provider inventory allocations. 💫

🎀 Resource Provider Inventories 🎀

Same proxy class, same big signature, still iconic:

class openstack.placement.v1._proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

`create_resource_provider_inventory(resource_provider, resource_class, *, total, **attrs)`

Create a new resource provider inventory from attributes. New inventory just dropped. 🛍️

Parameters

resource_provider — either the ID of a resource provider or a ResourceProvider (openstack.placement.v1.resource_provider.ResourceProvider) instance.
resource_class — the value can be either the ID of a resource class or an ResourceClass (openstack.placement.v1.resource_class.ResourceClass) instance.
total — the actual amount of the resource that the provider can accommodate. The real number, no cap. 🔢
attrs — keyword arguments which will be used to create a ResourceProviderInventory (openstack.placement.v1.resource_provider_inventory.ResourceProviderInventory), comprised of the properties on the ResourceProviderInventory class.

Returns

The results of resource provider inventory creation. 💅

`delete_resource_provider_inventory(resource_provider_inventory, resource_provider=None, ignore_missing=True)`

Delete a resource provider inventory. Bye-bye, inventory bestie. 👋

Parameters

resource_provider_inventory — the value can be either the ID of a resource provider or an ResourceProviderInventory (openstack.placement.v1.resource_provider_inventory.ResourceProviderInventory) instance.
resource_provider — either the ID of a resource provider or a ResourceProvider (openstack.placement.v1.resource_provider.ResourceProvider) instance. This value must be specified when resource_provider_inventory is an ID.
ignore_missing — when set to False, NotFoundException (openstack.exceptions.NotFoundException) will be raised when the resource provider inventory does not exist. When set to True, no exception will be set when attempting to delete a nonexistent resource provider inventory. 🫶

Returns

None.

`update_resource_provider_inventory(resource_provider_inventory, resource_provider=None, *, resource_provider_generation=None, **attrs)`

Update a resource provider’s inventory. Little refresh, but make it API. ✨

Parameters

resource_provider_inventory — the value can be either the ID of a resource provider inventory or an ResourceProviderInventory (openstack.placement.v1.resource_provider_inventory.ResourceProviderInventory) instance.
resource_provider — either the ID of a resource provider or a ResourceProvider (openstack.placement.v1.resource_provider.ResourceProvider) instance. This value must be specified when resource_provider_inventory is an ID.

Attrs kwargs

The attributes to update on the resource provider inventory represented by resource_provider_inventory. 🎀

Returns

The updated resource provider inventory.

`get_resource_provider_inventory(resource_provider_inventory, resource_provider=None)`

Get a single resource_provider_inventory. One inventory, no group chat. 💅

Parameters

resource_provider_inventory — the value can be either the ID of a resource provider inventory or an ResourceProviderInventory (openstack.placement.v1.resource_provider_inventory.ResourceProviderInventory) instance.
resource_provider — either the ID of a resource provider or a ResourceProvider (openstack.placement.v1.resource_provider.ResourceProvider) instance. This value must be specified when resource_provider_inventory is an ID.

Returns

An instance of ResourceProviderInventory (openstack.placement.v1.resource_provider_inventory.ResourceProviderInventory).

Raises

NotFoundException (openstack.exceptions.NotFoundException) when no resource provider inventory matching the criteria could be found. 😭

`resource_provider_inventories(resource_provider, **query)`

Retrieve a generator of resource provider inventories. Again: generator, not a list. 🌀

Parameters

resource_provider — either the ID of a resource provider or a ResourceProvider (openstack.placement.v1.resource_provider.ResourceProvider) instance.
query — optional query parameters to be sent to limit the resources being returned.

Returns

A generator of resource provider inventory instances. 💖

`set_resource_provider_inventories(resource_provider, inventories, resource_provider_generation)`

Replace all inventories for a resource provider in a single request. Big main character move: one request, all the inventories. 👑

Parameters

resource_provider — the value can be either the ID of a resource provider or a ResourceProvider (openstack.placement.v1.resource_provider.ResourceProvider) instance.
inventories — A dict mapping resource class names to inventory configuration dicts (keys: total, and optionally allocation_ratio, max_unit, min_unit, reserved, step_size). Pass an empty dict to remove all inventories. 🗂️
resource_provider_generation — The current generation of the resource provider, used to detect concurrent updates. 🔄

Returns — The resource provider with its generation updated to reflect the new state. ✨

Raises — ConflictException if the generation does not match or allocations prevent removal. 💥

delete_resource_provider_inventories(resource_provider) — Delete all inventory records for a resource provider. 🧹
- Parameters
  - resource_provider — The value can be either the ID of a resource provider or a ResourceProvider instance.
- Returns — None
- Raises — ConflictException if there are active allocations against the resource provider. 😬

✨ Traits ✨

class openstack.placement.v1._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

create_trait(name) — Create a new trait. 🌱
- Parameters
  - name — The name of the new trait.
- Returns — The results of trait creation.
delete_trait(trait, ignore_missing=True) — Delete a trait. 🫡
- Parameters
  - trait — The value can be either the ID of a trait or a Trait instance.
  - ignore_missing — When set to False, NotFoundException will be raised when the resource provider inventory does not exist. When set to True, no exception will be set when attempting to delete a nonexistent resource provider inventory.
- Returns — None
get_trait(trait) — Get a single trait. 🔍
- Parameters
  - trait — The value can be either the ID of a trait or a Trait instance.
- Returns — An instance of ResourceProviderInventory
- Raises — NotFoundException when no trait matching the criteria could be found.
traits(**query) — Retrieve a generator of traits. 🎐
- Parameters
  - query — Optional query parameters to be sent to limit the resources being returned.
- Returns — A generator of trait objects.

💜 Resource Provider Trait 💜

class openstack.placement.v1._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

get_resource_provider_trait(resource_provider) — Get a resource provider’s trait. 🧚
- Parameters
  - resource_provider — The value can be either the ID of a resource provider or an instance of ResourceProviderTrait.
- Returns — An instance of ResourceProviderTrait.
set_resource_provider_trait(resource_provider_trait, **attrs) — Update a resource provider’s trait. 🛠️
- Parameters
  - resource_provider_trait — An instance of ResourceProviderTrait.
- Attrs kwargs — The attributes to update on the resource provider trait represented by resource_provider_trait.
- Returns — The updated resource provider trait.
delete_resource_provider_trait(resource_provider, ignore_missing=True) — Dissociate all traits from a resource provider. ✂️
- Parameters
  - resource_provider — The value can be either the ID of a resource provider or a ResourceProvider instance.
  - ignore_missing — When set to False, NotFoundException will be raised when the resource provider does not exist. When set to True, no exception will be raised when attempting to delete traits for a nonexistent resource provider.
- Returns — None

🦋 Shared File System API 🦋

🎀 The Shared File System Class 🎀

The high-level interface for accessing the shared file systems service API is available through the shared_file_system member of a Connection object. The shared_file_system member will only be added if the service is detected. share is an alias of the shared_file_system member. 💖

🌈 Availability Zone Operation 🌈

Interact with Availability Zones supported by the Shared File Systems service. 🌍

class openstack.shared_file_system.v2._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

availability_zones() — Retrieve shared file system availability zones. 🗺️
- Returns — A generator of availability zone resources.

🌸 Limit Operations 🌸

Get absolute limits of resources supported by the Shared File Systems service. 📏

class openstack.shared_file_system.v2._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

limits(**query) — Lists all share limits. 📋
- Parameters
  - query — Optional query parameters to be sent to limit the share limits being returned.
- Returns — A generator of manila share limits resources.

⭐ Quota Class Set Operations ⭐

class openstack.shared_file_system.v2._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

get_quota_class_set(quota_class_set) — Get quota class set. 🎟️
- Parameters
  - quota_class_set — The name of the quota class or a QuotaClassSet instance.
- Returns — A QuotaClassSet.

`update_quota_class_set(quota_class_set, **attrs)`

okay so this one updates a quota class set. Parameters:

quota_class_set — The name of the quota class 💅
attrs — The attributes to update on the quota class set ✨

Returns: the updated quota class set 🫶

💖 Quota Set Operations 💖

bestie, this is the quota-set corner of the proxy. same iconic class signature, no cap:

class openstack.shared_file_system.v2._proxy.Proxy(session, *,
service_type=None, service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

`get_quota_set(project, **query)`

Retrieves a specific metadata item for the Quota Set. yes that is literally what it says, and we respect it 💫

Returns: A QuotaSets 🌸

`update_quota_set(project, **attrs)`

Updates details of a quota set. slay, let's edit.

Parameters:

project — ID or instance of Project <#openstack.identity.v3.project.Project> of the project for which the quota should be updated. 👑
attrs — The attributes to update on the quota set. ✨

Returns: The updated quota set 💖

`revert_quota_set(project)`

Reset quota set for a project. it's giving "undo button" energy.

Parameters:

project — ID or instance of Project <#openstack.identity.v3.project.Project> of the project for which the quota should be reset. 🌀

Returns: None 🫶

🌈 Service Operations 🌈

Interact with services supported by the Shared File Systems service. main character service-management moment.

class openstack.shared_file_system.v2._proxy.Proxy(session, *,
service_type=None, service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

`services(**query)`

Lists all services. cute. let's see what's running.

Parameters:

query — Optional query parameters to be sent to limit the services being returned. Available parameters include:
- host: The service host name.
- binary: The service binary name.
- zone: The availability zone.
- state: The current state of the service. A valid value is up or down.
- status: The service status, which is enabled or disabled.

Returns: A generator of manila service resources. 🦋

`disable_service(service, host, binary, *, disable_reason=None)`

Disable a service. not me hitting the off switch 💀

Parameters:

service — Either the ID of a service or a Service <#openstack.shared_file_system.v2.service.Service> instance.
host — The host where service runs.
binary — The name of service.
disable_reason — The reason for disabling the service.

Returns: Updated service instance 🌸

`enable_service(service, host, binary)`

Enable a service. and we're back on, periodt ✨

Parameters:

service — Either the ID of a service or a Service <#openstack.shared_file_system.v2.service.Service> instance.
host — The host where service runs.
binary — The name of service.

Returns: Updated service instance 💖

`ensure_shares_service(host)`

Run ensure shares on a back end. very "go check on the shares" of it all.

Parameters:

host — The host to run ensure shares on.

Interact with Shares supported by the Shared File Systems service. this is the share girlie section fr fr.

class openstack.shared_file_system.v2._proxy.Proxy(session, *,
service_type=None, service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

`shares(details=True, **query)`

Lists all shares with details. obsessed with a detailed list 💅

Parameters:

query — Optional query parameters to be sent to limit the shares being returned. Available parameters include:
- status: Filters by a share status
- share_server_id: The UUID of the share server.
- metadata: One or more metadata key and value pairs as a url encoded dictionary of strings.
- extra_specs: The extra specifications as a set of one or more key-value pairs.
- share_type_id: The UUID of a share type to query resources by.
- name: The user defined name of the resource to filter resources by.
- snapshot_id: The UUID of the share's base snapshot to filter the request based on.
- host: The host name of the resource to query with.
- share_network_id: The UUID of the share network to filter resources by.
- project_id: The ID of the project that owns the resource.
- is_public: A boolean query parameter that, when set to true, allows retrieving public resources that belong to all projects.
- share_group_id: The UUID of a share group to filter resource.
- export_location_id: The export location UUID that can be used to filter shares or share instances.
- export_location_path: The export location path that can be used to filter shares or share instances.
- name~: The name pattern that can be used to filter shares, share snapshots, share networks or share groups.
- description~: The description pattern that can be used to filter shares, share snapshots, share networks or share groups.
- with_count: Whether to show count in API response or not, default is False.
- limit: The maximum number of shares to return.
- offset: The offset to define start point of share or share group listing.
- sort_key: The key to sort a list of shares.
- sort_dir: The direction to sort a list of shares. A valid value is asc, or desc.

Returns: Details of shares resources 🌟

`find_share(name_or_id, ignore_missing=True, **query)`

Find a single share. detective mode: activated 🔍

Parameters:

name_or_id — The name or ID of a share.
ignore_missing — When set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the resource does not exist. When set to True, None will be returned when attempting to find a nonexistent resource. 🫶
query — Any additional parameters to be passed into underlying methods. such as query filters.

Returns: One Share <#openstack.shared_file_system.v2.share.Share> or None 🦋

`get_share(share)`

Lists details of a single share. just one little share, as a treat.

Parameters:

share — The value can be the ID of a share or a Share <#openstack.shared_file_system.v2.share.Share> instance.

Returns: Details of the identified share 💖

`delete_share(share, ignore_missing=True, *, force=False)`

Deletes a single share. okay bye bestie 👋

Parameters:

share — The value can be either the ID of a share or a Share <#openstack.shared_file_system.v2.share.Share> instance.
ignore_missing — set this to False and you'll get a NotFoundException <#openstack.exceptions.NotFoundException> thrown at you whenever the share doesn't exist. Set it to True and it just… doesn't care. No exception when you try to delete a share that isn't there. Honestly? Self-care. 💅
- force — set to True and the share deletion gets forced immediately. No waiting around, no queuing, just yeet. 🔥

Returns — None

`update_share(share, **attrs)`

Updates the details of a single share. Glow-up time ✨

Parameters

share — the ID of the share you're updating
attrs — the attributes you want to update on that share

Returns — the updated share, looking all fresh 🎀

`create_share(**attrs)`

Makes a brand new share out of attributes. Baby's first share, so proud 🥹

Parameters

attrs — the attributes used to create a Shares, made up of the properties on the Shares class. Important one, bestie: size and share are required to create a share. No cap.

Returns — the details of the new share 💖

`revert_share_to_snapshot(share, snapshot)`

Reverts a share back to the snapshot you specify — and heads up, it has to be the most recent snapshot known to manila. The way it's gotta be the latest one, no exceptions 👑

Parameters

share — the ID of the share to revert
snapshot — the ID of the snapshot to revert to

Returns — the result of the revert

`manage_share(protocol, export_path, service_host, **params)`

Manages a share. Very "adopting a stray" energy 🐾

Parameters

protocol — the shared file systems protocol of this share
export_path — the export path, formatted according to the protocol
service_host — the manage-share service host
params — optional parameters to be sent. The available ones are:
- name: the user defined name of the resource.
- share_type: the name or ID of the share type to be used to create the resource.
- driver_options: a set of one or more key and value pairs, as a dictionary of strings, that describe driver options.
- is_public: the level of visibility for the share.
- description: the user defiend description of the resource. (yes that typo is theirs, we keep it 💀)
- share_server_id: the UUID of the share server.

Returns — the share that was managed 🫶

`unmanage_share(share)`

Unmanages the share with the given share ID. Letting it go, it's not you it's me 😭

Parameters

share — the ID of the share to unmanage

Returns — None

`resize_share(share, new_size, no_shrink=False, no_extend=False, force=False)`

Resizes a share, extending or shrinking it as needed. Growth arc, or shrinkage arc, either way 🌸

Parameters

share — the ID of the share to resize
new_size — the new size of the share, in GiBs. If new_size is the same as the current size, then literally nothing happens. Nothing. Zip.
no_shrink — if set to True, the given share is not shrunk, even if shrinking is required to get it to the given size. Useful for extending shares up to a minimum size while not shrinking shares down to the given size. Defaults to False.
no_extend — if set to True, the given share is not extended, even if extending is required to get it to the given size. Useful for shrinking shares down to a maximum size while not extending smaller shares up to that maximum. Defaults to False.
force — whether or not force should be used, in the case where the share should be extended.

Returns — None

`soft_delete_share(share)`

Soft deletes a share. Gentle deletion. Soft launch into the void 🦋

Parameters

share — the value can be either the ID of a share or a Share <#openstack.shared_file_system.v2.share.Share> instance.

Returns — None

`restore_share(share)`

Restores the share with the given share ID. Bringing it back, main character return arc 👑

Parameters

share — the value can be either the ID of a share or a Share <#openstack.shared_file_system.v2.share.Share> instance.

Returns — None

`reset_share_status(share, status)`

Resets a share to the status you specify. Factory reset but make it cloud ☁️

Parameters

share — the ID of the share or the share object to reset
status — the status to reset the share to. Possible values include: available, error, and invalid.

Returns — None

Create, View, and Delete access rules for shares from the Shared File Systems service. Access rules can also have their deletion and visibility restricted during creation. A lock reason can also be specified. And the deletion restriction can be removed during the access removal. So many little knobs, we love a configurable queen 🎀

class openstack.shared_file_system.v2._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

`access_rules(share, **query)`

Lists the access rules on a share. Read the room, read the rules 📋

Returns — a generator of the share access rules

`get_access_rule(access_rule)`

Lists details of an access rule. Getting the full dossier 🔍

Parameters

access_rule — the value can be the ID of an access rule or a ShareAccessRule <#openstack.shared_file_system.v2.share_access_rule.ShareAccessRule> instance.

Returns — the details of the identified access rule

`create_access_rule(share, **attrs)`

Creates an access rule from attributes. New rule just dropped ✨

Parameters

share — the ID of the share
attrs — the attributes used to create a ShareAccessRules, made up of the properties on the ShareAccessRules class.

Returns — the details of the new access rule

`delete_access_rule(access_rule, share, ignore_missing=True, *, unrestrict=False)`

Deletes an access rule. Bye bestie 👋

Parameters

access_rule — the value can be either the ID of an access rule or a ShareAccessRule <#openstack.shared_file_system.v2.share_access_rule.ShareAccessRule> instance.
share — the ID of the share.
ignore_missing — when set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the access rule does not exist. When set to True, no exception will be set when attempting to delete a nonexistent access rule. (Default is True, so it's forgiving by default, love that for you 💜)
unrestrict — if Manila must attempt removing locks while deleting.

Returns — requests.models.Response HTTP response from the internal requests client

Interact with Share groups supported by the Shared File Systems service. Squad goals, but storage ☁️💖

class openstack.shared_file_system.v2._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

`share_groups(**query)`

Lists all share groups. Roll call! 🗣️

Parameters

query — optional query parameters to send along to limit the share groups being returned. The available ones are:
- status: filters by a share group status.
- name: the user defined name of the resource to filter resources by.
- description: the user defined description text that can be used to filter resources.
- project_id: the project ID of the user or service.
share_server_id — the UUID of the share server 🖥️
- snapshot_id — the UUID of the share's base snapshot, so you can filter the request based on it 📸
- host — the host name for the back end 🏠
- share_network_id — the UUID of the share network you wanna filter resources by 🌐
- share_group_type_id — the share group type ID, used to filter share groups 🗂️
- share_group_snapshot_id — the source share group snapshot ID, for listing the share group 💫
- share_types — a list of one or more share type IDs. Lets you filter share groups ✨
- limit — the max number of share groups members to return 🔢
- offset — the offset that defines the start point of the share or share group listing 📍
- sort_key — the key to sort a list of shares 🔑
- sort_dir — the direction to sort a list of shares ↕️
- name~ — the name pattern you can use to filter shares, share snapshots, share networks or share groups 🔍
- description~ — the description pattern you can use to filter shares, share snapshots, share networks or share groups 📝

Returns

A generator of manila share group resources 💖

Lists details for a share group. Like, the full tea 👀

Parameters

share_group — the value can be the ID of a share group or a ShareGroup <#openstack.shared_file_system.v2.share_group.ShareGroup> instance.

Returns

Details of the identified share group ✨

Finds a single share group. Just the one. No cap 🎯

Parameters

name_or_id — the name or ID of a share group.
ignore_missing — when it's set to False, NotFoundException <#openstack.exceptions.NotFoundException> gets raised if the resource doesn't exist. When it's True, None gets returned instead when you try to find a resource that isn't there 🙈

Returns

One ShareGroup <#openstack.shared_file_system.v2.share_group.ShareGroup> or None

Creates a share group from attributes. Build-a-group workshop 🛠️

Returns

Details of the new share group 🎀

Updates details of a single share group. Glow-up time 💅

Parameters

share_group — the ID of the share group

Returns

Updated details of the identified share group ✨

Deletes a single share group. Gone, bye 👋

Parameters

share_group — the value can be either the ID of a share group or a ShareGroup <#openstack.shared_file_system.v2.share_group.ShareGroup> instance.
ignore_missing — when it's set to False, NotFoundException <#openstack.exceptions.NotFoundException> gets raised when the share group doesn't exist. When it's True, no exception gets set when you try to delete a share group that isn't there 💀

Returns

The deleted share group.

Interact with Share Group Snapshots by the Shared File Systems service. Literally its whole job 💜

class openstack.shared_file_system.v2._proxy.Proxy(session, *,
service_type=None, service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

Lists all share group snapshots. The whole collection, bestie 🗃️

Parameters

query —

Optional query parameters that get sent along to limit the share group snapshots being returned. The available parameters include:

project_id — the ID of the project that owns the resource 🏷️
name — the user defined name of the resource, for filtering resources 🔍
description — the user defined description text that can be used to filter resources 📝
status — filters by a share status 🚦
share_group_id — the UUID of a share group to filter resource 🆔
limit — the max number of share group snapshot members to return 🔢
offset — the offset that defines the start point of the share or share group listing 📍
sort_key — the key to sort a list of shares 🔑
sort_dir — the direction to sort a list of shares. A valid value is asc, or desc ↕️

Returns

Details of share group snapshots resources ✨

Show share group snapshot details. Spill the details, honestly 👀

Parameters

group_snapshot — the value can be the ID of a share group snapshot or a ShareGroupSnapshot <#openstack.shared_file_system.v2.share_group_snapshot.ShareGroupSnapshot> instance.

Returns

Details of the group snapshot 💖

Creates a point-in-time snapshot copy of a share group. Freeze frame, but make it storage 📸

Parameters

share_group — ID of the share group to have the snapshot taken.
attrs — attributes which will be used to create a ShareGroupSnapshots,

Returns

Details of the new snapshot 🎀

Reset share group snapshot state. Ctrl+Z for the state machine, kinda 🔄

Parameters

group_snapshot — the ID of the share group snapshot to reset
status — the state of the share group snapshot to be set, a valid value is "creating", "error", "available", "deleting", "error_deleting".

Updates a share group snapshot ✨

Parameters

group_snapshot — the ID of the share group snapshot to update
attrs — the attributes to update on the share group snapshot

Returns

the updated share group snapshot 💅

Deletes a share group snapshot. Yeet 🗑️

Parameters

group_snapshot — the value can be either the ID of a share group snapshot or a ShareGroupSnapshot <#openstack.shared_file_system.v2.share_group_snapshot.ShareGroupSnapshot> instance.
ignore_missing — when it's set to False, NotFoundException <#openstack.exceptions.NotFoundException> gets raised when the share group snapshot doesn't exist. When it's True, no exception gets set when you try to delete a share group snapshot that isn't there 💀

Returns

None

Admins can list, show information for, explicitly set the state of, and force-delete share instances within the Shared File Systems Service. Admin business only, fr fr 🔐

class openstack.shared_file_system.v2._proxy.Proxy(session, *,
service_type=None, service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

Lists all share instances 📋

Parameters

query —

Optional query parameters that get sent along to limit the share instances being returned. The available parameters include:

export_location_id — the export location UUID that can be used to filter share instances 🆔
export_location_path — the export location path that can be used to filter share instances 🛤️

Returns

Details of share instances resources ✨

Shows details for a single share instance 👀

Parameters

share_instance — the value can be the UUID of a share instance or a ShareInstance instance. 🦋

Returns — Details of the identified share instance

Explicitly updates the state of a share instance. 💅

Parameters

share_instance — The UUID of the share instance to reset.
status — The share or share instance status to be set.

Returns — None

Force-deletes a share instance 😭💥

Parameters

share_instance — The value can be either the ID of a share instance or a ShareInstance instance.
ignore_missing — When set to False NotFoundException will be raised when the share instance does not exist. When set to True, no exception will be set when attempting to delete a nonexistent share instance.

Returns — None

List, Get, Create, Update, and Delete metadata for shares from the Shared File Systems service. 🎀

class openstack.shared_file_system.v2._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

Lists all metadata for a share. 🧚

🚨 Deprecated since version 4.14.0: Use fetch_share_metadata() instead.

Retrieves a specific metadata item from a share by its key. 🔑

🚨 Deprecated since version 4.14.0: Use fetch_share_metadata_item() instead.

Creates share metadata as key-value pairs. 💖

🚨 Deprecated since version 4.14.0: Use set_share_metadata() instead.

Updates metadata of given share. ✨

🚨 Deprecated since version 4.14.0: Use set_share_metadata() instead.

Deletes metadata for a share. 🫶

Parameters

share — The value can be either the ID of a share or a Share instance.
keys — The list of share metadata keys to be deleted.
ignore_missing — When set to True, missing keys will be logged but not cause a failure. When set to False, missing keys will be included in the failure list.

Returns — None

Create and manipulate Share Networks with the Shared File Systems service. 👑

class openstack.shared_file_system.v2._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

Lists all share networks with details. 🦋

Parameters

query — Optional query parameters to be sent to limit the resources being returned. Available parameters include:
- name~: The user defined name of the resource to filter resources by.
- project_id: The ID of the user or service making the request.
- description~: The description pattern that can be used to filter shares, share snapshots, share networks or share groups.
- all_projects: (Admin only). Defines whether to list the requested resources for all projects.

Returns — Details of shares networks

Lists details of a single share network. 🌸

Parameters

share_network — The value can be the ID of a share network or a ShareNetwork instance.

Returns — Details of the identified share network

Deletes a single share network. 💀

Parameters

share_network — The value can be either the ID of a share network or a ShareNetwork instance.
ignore_missing — When set to False NotFoundException will be raised when the share network does not exist. When set to True, no exception will be set when attempting to delete a nonexistent share network.

Returns — None

Updates details of a single share network. ✨

Parameters

share_network — The ID of the share network to update.
attrs — The attributes to update on the share network.

Returns — the updated share network

Creates a share network from attributes. 🎀

Returns — Details of the new share network

Parameters

attrs — Attributes which will be used to create a ShareNetwork,comprised of the properties on the ShareNetwork class.

Create and manipulate Share Network Subnets with the Shared File Systems service. ⭐

class openstack.shared_file_system.v2._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

Lists all share network subnets with details. 🌈

Parameters

share_network — The id of the share network for which Share Network Subnets should be listed.

Returns — A generator of manila share network subnets

Lists details of a single share network subnet. 🔥

Parameters

share_network — The value can be the ID of a share network or a ShareNetwork instance.
share_network_subnet — The value can be the ID of a share network subnet or a ShareNetworkSubnet instance.

Returns — Details of the identified share network subnet

Creates a share network subnet from attributes. 🧚

Parameters

share_network — The id of the share network wthin which the the Share Network Subnet should be created.
attrs — Attributes which will be used to create a share network subnet.

Returns — Details of the new share network subnet.

Deletes a share network subnet. 💥

Parameters

…and the params it takes:

share_network — ngl you can pass either the ID of a share network or an actual ShareNetwork instance, whichever you have lying around 💅
share_network_subnet — same energy: either the ID of a share network subnet or a ShareNetworkSubnet instance.
ignore_missing — set this to False and boom, NotFoundException gets raised when the share network subnet doesn't exist. Set it to True and literally nothing happens when you try to delete a nonexistent share network subnet — no exception, no drama, no cap.

Returns

None — that's it, that's the whole return value, bestie 💀

fetch_share_network_subnet_metadata(share_network, share_network_subnet)

Lists, like, all the metadata of a given share network subnet. Every last crumb 🍓

Parameters

share_network — the ID of a share network or a ShareNetwork instance.
share_network_subnet — the ID of a share network subnet or a ShareNetworkSubnet instance.

Returns

Details of the identified share network subnet, including its metadata. Iconic.

fetch_share_network_subnet_metadata_item(share_network, share_network_subnet, key)

Retrieve one specific subnet metadata item, by key. Very "I know exactly what I'm looking for" of you ✨

Parameters

share_network — the ID of a share network or a ShareNetwork instance.
share_network_subnet — the ID of a share network subnet or a ShareNetworkSubnet instance.
key — the key of the Share Network Subnet Metadata.

Returns

A single metadata key and value pair. One (1) little guy 🎀

set_share_network_subnet_metadata(share_network, share_network_subnet, *, replace=False, **metadata)

Updates metadata of given share network subnet. Glow-up time 🌸

Parameters

share_network — the ID of a share network or a ShareNetwork instance.
share_network_subnet — the ID of a share network subnet or a ShareNetworkSubnet instance.
metadata — the metadata to be created.

Returns

Details of the identified share network subnet.

delete_share_network_subnet_metadata(share_network, share_network_subnet, keys, ignore_missing=True)

Deletes one or more subnet metadata items, identified by their keys. Bye bestie 👋

Parameters

share_network — the ID of a share network or a ShareNetwork instance.
share_network_subnet — the ID of a share network subnet or a ShareNetworkSubnet instance.
keys — the keys of the metadata items to be deleted.

Returns

None — nothing back, just vibes 🫶

Interact with share replicas, which the Shared File Systems service supports. Copies upon copies, we love redundancy 💜

class openstack.shared_file_system.v2._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

💫 `create_share_replica(share, **attrs)`

Creates a share replica from attributes. New replica just dropped 🔥

Parameters

share — Id of the share for which share replica is to be created.
attrs — optional attributes which will be used to create. Available parameters include:
- availability_zone: availability zone in which replica should be created.

Returns

Details of the new share replica.

💫 `share_replicas(**attrs)`

List all share replicas with all details. The full tea ☕

Parameters

attrs — optional parameters to limit the share replicas being returned. Available parameters include:
- share_id: id of the share for which share replicas are wanted
- columns: list of columns to be displayed in the returned list

Returns

A generator of share replicas.

💫 `get_share_replica(share_replica)`

List details of a single share replica. Just the one, main character style 👑

Parameters

share_replica — Id of the share replica.

Returns

Details of the identified share replica.

💫 `delete_share_replica(share_replica, ignore_missing=True, force=False)`

Delete a share replica. Gone, reduced to atoms 💀

Parameters

share_replica — Id of the share replica.

Returns

Result of delete on share replica.

💫 `reset_share_replica_status(share_replica, status)`

Reset status of the share replica. Factory reset but make it storage 🧚

Parameters

share_replica — Id of the share replica.
status — set the status to the share replica. Possible values include: available, error, creating, deleting, or error_deleting.

Returns

None.

💫 `reset_share_replica_state(share_replica, replica_state)`

Reset replica_state of the share replica. Different reset, same energy ✨

Parameters

share_replica — Id of the share replica.
replica_state — the replica state of a share replica. Possible values include: active, in_sync, out_of_sync, and error.

Returns

None.

💫 `promote_share_replica(share_replica)`

Promote share replica. Give it a lil promotion, it earned it 🎀

Parameters

share_replica — Id of the share replica.

Returns

None.

💫 `resync_share_replica(share_replica)`

Resync share replica. Get it back in sync with the group chat 🫶

Parameters

share_replica — Id of the share replica.

Returns

None.

Interact with Share Snapshots, which the Shared File Systems service supports. Freeze frame, but for storage 📸

class openstack.shared_file_system.v2._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

🌸 `share_snapshots(details=True, **query)`

Lists all share snapshots with details. All of them. Every single one 💅

Parameters

query — optional query parameters to be sent to limit the snapshots being returned. Available parameters include:
- project_id: the ID of the user or service making the API request.

Returns

A generator of manila share snapshot resources.

🌸 `get_share_snapshot(snapshot)`

Lists details of a single share snapshot. Spotlight on one 🎤

Parameters

snapshot — the value can be the ID of a share snapshot or a ShareSnapshot instance.

Returns

Details of the identified share snapshot.

🌸 `create_share_snapshot(**attrs)`

Creates a share snapshot from attributes. New snapshot, who dis 💖

Returns

Details of the new share snapshot.

update_share_snapshot(snapshot, **attrs)

Okay bestie, this is the little glow-up button for one share ✨

Parameters

snapshot — The ID of the snapshot to update
attrs — The attributes to update on the snapshot

Returns: the updated share snapshot — iconic 💅

delete_share_snapshot(snapshot, ignore_missing=True, *, force=False)

Deletes a single share snapshot. Bye-bye, snapshot 🫶

Parameters

snapshot — The value can be either the ID of a share snapshot or a ShareSnapshot instance (class path openstack.shared_file_system.v2.share_snapshot.ShareSnapshot).
ignore_missing — When set to False, NotFoundException (class path openstack.exceptions.NotFoundException) will be raised when the share snapshot does not exist. When set to True, no exception will be set when attempting to delete a nonexistent share snapshot.
force — When set to True, the share snapshot deletion will be forced immediately.

Returns: None

🚨 Heads up: force=True means the deletion is forced immediately. No chill, no waiting around.

reset_share_snapshot_status(snapshot, status)

Reset status of share snapshot. A little reset era for your snapshot 🌸

Parameters

snapshot — The ID of the snapshot or the snapshot object to reset
status — The status of the snapshot to reset to.

Returns: None

manage_share_snapshot(share, provider_location, **params)

Manage a share snapshot. Bringing it under your wing 💖

Parameters

share — The ID of the share that has snapshot which should be managed.
provider_location — Provider location of the snapshot on the backend.
params — Optional parameters to be sent. Available parameters include:
- name: The user defined name of the resource.
- display_name: The user defined name of the resource. This field sets the name parameter.
- description: The user defined description of the resource.
- display_description: The user defined description of the resource. This field sets the description parameter.
- driver_options: A set of one or more key and value pairs, as a dictionary of strings, that describe driver options.

Returns: The share snapshot that was managed.

unmanage_share_snapshot(snapshot)

Unmanage the share snapshot with the given snapshot ID. Letting it go, lowkey 🦋

Parameters

snapshot — The ID of the share snapshot to unmanage.

Returns: None

fetch_share_snapshot_metadata(snapshot)

Lists all metadata for a given snapshot. Metadata scavenger hunt 🔥

Parameters

snapshot — The value can be the ID of a share snapshot or a ShareSnapshot instance (class path openstack.shared_file_system.v2.share_snapshot.ShareSnapshot).

Returns: One or more metadata key and value pairs as a dictionary of strings.

fetch_share_snapshot_metadata_item(snapshot, key)

Retrieves a specific metadata item from a snapshot's metadata by its key. One little metadata gem at a time 🎀

Parameters

snapshot — The value can be the ID of a share snapshot or a ShareSnapshot instance (class path openstack.shared_file_system.v2.share_snapshot.ShareSnapshot).
key — The key of the snapshot metadata.

Returns: A single metadata key and value pair.

set_share_snapshot_metadata(snapshot, *, replace=False, **metadata)

Updates metadata of given share snapshot. Metadata makeover time ✨

Parameters

snapshot — The value can be the ID of a share snapshot or a ShareSnapshot instance (class path openstack.shared_file_system.v2.share_snapshot.ShareSnapshot).
replace — Boolean for whether the preexisting metadata should be replaced
metadata — The metadata to be created.

Returns: One or more metadata key and value pairs as a dictionary of strings.

delete_share_snapshot_metadata(snapshot, keys)

Deletes metadata for a snapshot. Clean sweep 🧚

Parameters

snapshot — The value can be the ID of a share snapshot or a ShareSnapshot instance (class path openstack.shared_file_system.v2.share_snapshot.ShareSnapshot).
keys — The keys of the metadata items to be deleted.

Returns: None

Interact with Share Snapshot Instances supported by the Shared File Systems service.

class openstack.shared_file_system.v2._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

share_snapshot_instances(details=True, **query)

Lists all share snapshot instances with details. It's giving inventory energy 💜

Parameters

details — Whether to fetch detailed resource descriptions. Defaults to True.
query — Optional query parameters to be sent to limit the share snapshot instance being returned. Available parameters include:
- snapshot_id: The UUID of the share's base snapshot to filter the request based on.
- project_id: The project ID of the user or service making the request.

Returns: A generator of share snapshot instance resources

get_share_snapshot_instance(share_snapshot_instance)

Lists details of a single share snapshot instance. One snapshot instance, main character spotlight 👑

Parameters

share_snapshot_instance — The value can be the ID of a share snapshot instance or a ShareSnapshotInstance instance (class path openstack.shared_file_system.v2.share_snapshot_instance.ShareSnapshotInstance).

Returns: Details of the identified snapshot instance

Interact with Share Types supported by the Shared File Systems service.

class openstack.shared_file_system.v2._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

share_types(**query)

List shared file system share types. Share type catalog vibes 🛍️

Parameters

query — Optional query parameters to be sent to limit the share types being returned. Available parameters include:
- extra_specs: The extra specifications as a set of one or more key-value pairs.
- is_public: A boolean query parameter that, when set to true, allows retrieving public resources that belong to all projects.

Returns: A generator of share type resources

get_share_type(share_type)

List details of a single share type. Peeking at one share type's whole deal 🔍

Parameters

share_type — The ID of the share type

Returns: Details of identified share type

create_share_type(name, **attrs)

Creates a share from attributes. New share type just dropped 💖

Returns: Details of the new share type

Parameters

name — Name of the new share type
attrs — Attributes which will be used to create a ShareType (class path openstack.shared_file_system.v2.share_type.ShareType), comprised of the properties on the ShareType class. Currently "description" and "extra_specs" are allowed attributes.

delete_share_type(share_type, ignore_missing=True)

Deletes a single share type. Another one bites the dust 💀

Parameters

share_type — the ID of the share type 💖

Returns None — that's it, nothing comes back, periodt.

`update_share_type(share_type, **attrs)`

Updates details of one single share type, lowkey precise.

Parameters

share_type — the ID of the share type to update.
attrs — the attributes to update on the share type.

Returns Updated details of the identified share type ✨

`update_share_type_extra_specs(share_type, **attrs)`

Updates the extra_specs for a type. Yes bestie, the signature says **attrs and the parameter is extra_specs — that's just how it is.

Parameters

share_type — The ID of the share type.
extra_specs — The extra specs to update on the share type.

Returns The updated share type.

`delete_share_type_extra_spec_property(share_type, prop, ignore_missing=False)`

Deletes the extra_specs for a share type. Cleanup era 🧹

Parameters

share_type_id — The ID of the share type.
prop — The extra spec to delete.
ignore_missing — When set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the flavor or extra spec does not exist. When set to True, no exception will be set when attempting to delete a nonexistent flavor extra spec.

Returns None

🫧 Storage Pool Operations 🫧

Interact with the storage pool statistics exposed by the Shared File Systems Service. Pool stats, but make it a vibe.

Same Proxy constructor signature, still iconic:

class openstack.shared_file_system.v2._proxy.Proxy(session, *,
service_type=None, service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

`storage_pools(details=True, **query)`

Lists all back-end storage pools with details. We love a detailed pool moment 🫶

Parameters

query — Optional query parameters to be sent to limit the storage pools being returned. Available parameters include:
- pool_name: The pool name for the back end.
- host_name: The host name for the back end.
- backend_name: The name of the back end.
- capabilities: The capabilities for the storage back end.
- share_type: The share type name or UUID.

Returns A generator of manila storage pool resources 🌈

🔐 Resource Lock Operations 🔐

Create, list, update and delete locks for resources. When a resource is locked, it means that it can be deleted only by services, admins or the user that created the lock. So yes, the lock is the main character.

Same Proxy constructor signature, again, because consistency ate:

class openstack.shared_file_system.v2._proxy.Proxy(session, *,
service_type=None, service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

`resource_locks(**query)`

Lists all resource locks. Lock listing, but make it filtered 💅

Parameters

query — Optional query parameters to be sent to limit the resource locks being returned. Available parameters include:
- project_id: The project ID of the user that the lock is created for.
- user_id: The ID of a user to filter resource locks by.
- all_projects: list locks from all projects (Admin Only)
- resource_id: The ID of the resource that the locks pertain to filter resource locks by.
- resource_action: The action prevented by the filtered resource locks.
- resource_type: The type of the resource that the locks pertain to filter resource locks by.
- lock_context: The lock creator's context to filter locks by.
- lock_reason: The lock reason that can be used to filter resource locks. (Inexact search is also available with lock_reason~)
- created_since: Search for the list of resources that were created after the specified date. The date is in 'yyyy-mm-dd' format.
- created_before: Search for the list of resources that were created prior to the specified date. The date is in 'yyyy-mm-dd' format.
- limit: The maximum number of resource locks to return.
- offset: The offset to define start point of resource lock listing.
- sort_key: The key to sort a list of shares.
- sort_dir: The direction to sort a list of shares
- with_count: Whether to show count in API response or not, default is False. This query parameter is useful with pagination.

Returns A generator of manila resource locks 🔥

`get_resource_lock(resource_lock)`

Shows details of a resource lock. Gimme the lore 👑

Parameters

resource_lock — The ID of a resource lock or a ResourceLock instance.

Returns Details of the identified resource lock.

`update_resource_lock(resource_lock, **attrs)`

Updates details of a single resource lock. Glow-up service, but for locks.

Parameters

resource_lock — The ID of a resource lock or a ResourceLock instance.
attrs — The attributes to update on the resource lock.

Returns the updated resource lock

`delete_resource_lock(resource_lock, ignore_missing=True)`

Deletes a single resource lock. Bye bestie 🦋

Parameters

resource_lock — The ID of a resource lock or a ResourceLock instance.
ignore_missing — When set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the resource lock does not exist. When set to True, no exception will be set when attempting to delete a nonexistent resource lock.

Returns The deleted resource lock.

`create_resource_lock(**attrs)`

Locks a resource. Lock it down, respectfully 🔒

Parameters

attrs — Attributes which will be used to create a ResourceLock, comprised of the properties on the ResourceLock class. Available parameters include:
- resource_id: ID of the resource to be locked.
- resource_type: type of the resource (share, access_rule).
- resource_action: action to be locked (delete, show).
- lock_reason: reason why you're locking the resource (Optional).

Returns Details of the lock

💌 User Message Operations 💌

View and manipulate asynchronous user messages emitted by the Shared File Systems service. Messages, but they're asynchronous and a little mysterious.

Same Proxy constructor signature one more time, because it's literally the same class:

class openstack.shared_file_system.v2._proxy.Proxy(session, *,
service_type=None, service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

`user_messages(**query)`

Lists shared file system user messages 📬

Parameters

query — Optional query parameters to be sent to limit the messages being returned. Available parameters include:
action_id — the ID of the action during which the message was created. 🕵️‍♀️
- detail_id — the ID of the message detail.
- limit — the maximum number of shares to return. (yes, shares — that's literally what it says 💀)
- message_level — the message level.
- offset — the offset that defines the start point of share or share group listing.
- sort_key — the key to sort a list of messages by.
- sort_dir — the direction to sort a list of shares.
- project_id — the ID of the project for which the message was created.
- request_id — the ID of the request during which the message was created.
- resource_id — the UUID of the resource for which the message was created.
- resource_type — the type of the resource for which the message was created.

Returns — a generator of user message resources.

get_user_message(message) — lists the deets of a single user message 💌

Parameters

message — the value can be the ID of a user message or a UserMessage <#openstack.shared_file_system.v2.user_message.UserMessage> instance.

Returns — details of the identified user message.

delete_user_message(message, ignore_missing=True) — deletes a single user message 🗑️

Parameters

message — the value can be either the ID of a user message or a UserMessage <#openstack.shared_file_system.v2.user_message.UserMessage> instance.
ignore_missing — when set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the user message does not exist. When set to True, no exception will be set when attempting to delete a nonexistent user message.

Returns — the deleted user message.

🦋 Workflow API 🦋

✨ The Workflow Class ✨

The workflow high-level interface is available through the workflow member of a Connection <#openstack.connection.Connection> object. The workflow member will only be added if the service is detected. 👑

🌸 Workflow Operations 🌸

class openstack.workflow.v2._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

`create_workflow(**attrs)`

Creates a new workflow from attributes. ✨

Parameters

attrs — keyword arguments which will be used to create a Workflow <#openstack.workflow.v2.workflow.Workflow>, comprised of the properties on the Workflow class.

Returns — the results of workflow creation.

`update_workflow(workflow, **attrs)`

Updates a workflow from attributes. 🛠️

Parameters

workflow — the value can be either the name of a workflow or a Workflow <#openstack.workflow.v2.workflow.Workflow> instance.
attrs — keyword arguments which will be used to update a Workflow <#openstack.workflow.v2.workflow.Workflow>, comprised of the properties on the Workflow class.

Returns — the results of workflow update.

`get_workflow(workflow)`

Gets a workflow. 🎯

Parameters

workflow — the value can be the name of a workflow or Workflow <#openstack.workflow.v2.workflow.Workflow> instance.

Returns — one Workflow <#openstack.workflow.v2.workflow.Workflow>.

Raises NotFoundException <#openstack.exceptions.NotFoundException> when no workflow matching the name could be found.

`workflows(**query)`

Retrieves a generator of workflows. 🌊

Parameters

query — optional query parameters to be sent to restrict the workflows to be returned. Available parameters include:
- limit — requests at most the specified number of items be returned from the query.
- marker — specifies the ID of the last-seen workflow. Use the limit parameter to make an initial limited request and use the ID of the last-seen workflow from the response as the marker parameter value in a subsequent limited request.

Returns — a generator of workflow instances.

`delete_workflow(value, ignore_missing=True)`

Deletes a workflow. 💥

Parameters

value — the value can be either the name of a workflow or a Workflow <#openstack.workflow.v2.workflow.Workflow> instance.
ignore_missing — when set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the workflow does not exist. When set to True, no exception will be set when attempting to delete a nonexistent workflow.

Returns — the deleted workflow.

`find_workflow(name_or_id, ignore_missing=True)`

Finds a single workflow. 🔎

Parameters

name_or_id — the name or ID of an workflow.
ignore_missing — when set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the resource does not exist. When set to True, None will be returned when attempting to find a nonexistent resource.

Returns — One Extension or None (yes bestie, Extension — we're just reading the menu 💀).

🎀 Execution Operations 🎀

class openstack.workflow.v2._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

`create_execution(**attrs)`

Creates a new execution from attributes. 🔥

Parameters

workflow_name — the name of target workflow to execute.
attrs — keyword arguments which will be used to create a Execution <#openstack.workflow.v2.execution.Execution>, comprised of the properties on the Execution class.

Returns — the results of execution creation.

`get_execution(execution)`

Gets a execution. 👀

Parameters

execution — the value can be either the ID of a execution or a Execution <#openstack.workflow.v2.execution.Execution> instance.

Returns — one Execution <#openstack.workflow.v2.execution.Execution>.

Raises NotFoundException <#openstack.exceptions.NotFoundException> when no execution matching the criteria could be found.

`executions(**query)`

Retrieves a generator of executions. 🌈

Parameters

query — optional query parameters to be sent to restrict the executions to be returned. Available parameters include:
- limit — requests at most the specified number of items be returned from the query.
- marker — specifies the ID of the last-seen execution. Use the limit parameter to make an initial limited request and use the ID of the last-seen execution from the response as the marker parameter value in a subsequent limited request.

Returns — a generator of execution instances.

`delete_execution(value, ignore_missing=True)`

Deletes an execution. 💅

Parameters

value — the value can be either the name of a execution or a Execution instance.
ignore_missing — set this to False and boom 💀 a NotFoundException (openstack.exceptions.NotFoundException) gets raised the moment the execution doesn't exist. Set it to True and literally nothing happens — no exception gets set when you try to delete a nonexistent execution. It's giving "no thoughts, head empty" and honestly? valid 🫶

Returns — the deleted execution.

`find_execution(name_or_id, ignore_missing=True)`

Find a single execution. One. Just one. 🔍

Parameters

name_or_id — the name or ID of an execution.
ignore_missing — set it to False and NotFoundException (openstack.exceptions.NotFoundException) will be raised when the resource does not exist. Set it to True and you just get None back when you try to find a nonexistent resource. no crash, no drama, no tears ✨

Returns — one Execution or None.

⏰ Cron Trigger Operations

Okay bestie, same proxy energy, but now with cron — yes, the actual scheduled-vibes kind 👑

class openstack.workflow.v2._proxy.Proxy(session, *, service_type=None, service_name=None, interface=None, region_name=None, endpoint_override=None, version=None, auth=None, user_agent=None, connect_retries=None, logger=None, allow=None, additional_headers=None, client_name=None, client_version=None, allow_version_hack=None, global_request_id=None, min_version=None, max_version=None, default_microversion=None, status_code_retries=None, retriable_status_codes=None, raise_exc=None, rate_limit=None, concurrency=None, connect_retry_delay=None, status_code_retry_delay=None, statsd_client=None, statsd_prefix=None, prometheus_counter=None, prometheus_histogram=None, influxdb_config=None, influxdb_client=None)

`create_cron_trigger(**attrs)`

Create a new cron trigger from attributes ✨

Parameters

attrs — keyword arguments which will be used to create a CronTrigger (openstack.workflow.v2.cron_trigger.CronTrigger), comprised of the properties on the CronTrigger class.

Returns — the results of cron trigger creation 💖

`get_cron_trigger(cron_trigger)`

Get a cron trigger. grabbing exactly one, bestie 🎀

Parameters

cron_trigger — the value can be the name of a cron_trigger or a CronTrigger (openstack.workflow.v2.cron_trigger.CronTrigger) instance.

Returns — one CronTrigger (openstack.workflow.v2.cron_trigger.CronTrigger)

Raises NotFoundException (openstack.exceptions.NotFoundException) when no cron triggers matching the criteria could be found. 😭

`cron_triggers(*, all_projects=False, **query)`

Retrieve a generator of cron triggers 🌈

Parameters

all_projects — when set to True, list cron triggers from all projects. Admin-only by default. 👑
query — optional query parameters to be sent to restrict the cron triggers to be returned. Available parameters include:
- limit: requests at most the specified number of items be returned from the query.
- marker: specifies the ID of the last-seen cron trigger. Use the limit parameter to make an initial limited request and use the ID of the last-seen cron trigger from the response as the marker parameter value in a subsequent limited request. iykyk 🧚

Returns — a generator of CronTrigger instances.

`delete_cron_trigger(value, ignore_missing=True)`

Delete a cron trigger. bye bestie 💅

Parameters

value — the value can be either the name of a cron trigger or a CronTrigger (openstack.workflow.v2.cron_trigger.CronTrigger) instance.
ignore_missing — when set to False, NotFoundException (openstack.exceptions.NotFoundException) will be raised when the cron trigger does not exist. When set to True, no exception will be set when attempting to delete a nonexistent cron trigger. ghost it and it won't ghost you back 🫶

Returns — the deleted cron trigger.

`find_cron_trigger(name_or_id, ignore_missing=True, *, all_projects=False, **query)`

Find a single cron trigger 🔎

Parameters

name_or_id — the name or ID of a cron trigger.
ignore_missing — when set to False, NotFoundException (openstack.exceptions.NotFoundException) will be raised when the resource does not exist. When set to True, None will be returned when attempting to find a nonexistent resource.
all_projects — when set to True, search for cron triggers by name across all projects. Note that this will likely result in a higher chance of duplicates. ⚠️ (fair warning, bestie)
query — optional query parameters to be sent to limit the cron triggers being returned.

Returns — one CronTrigger or None

Raises NotFoundException (openstack.exceptions.NotFoundException) when no resource can be found.

Raises DuplicateResource (openstack.exceptions.DuplicateResource) when multiple resources are found. two of them?? not the duplicate situation 😭

🧱 Resource Interface

Okay so this is the lowkey lower-level layer — the Resource layer is how you talk to OpenStack services directly, no middleman vibes. The classes exposed by the Connection build a whole convenience layer on top of this, but you can absolutely use Resources directly. However — the most common usage of this layer is getting an object from a class in the Connection layer, modifying it, and sending it right back into the Connection layer, like to update a resource on the server. it's giving "borrow the hoodie, wear it, give it back" 🧥✨

The following services have exposed Resource classes.

⚡ Accelerator v2 Resources

`openstack.accelerator.v2.accelerator_request`

The AcceleratorRequest Class

The AcceleratorRequest class inherits from Resource (openstack.resource.Resource).

class openstack.accelerator.v2.accelerator_request.AcceleratorRequest(_synchronized=False, connection=None, **attrs)

The base resource 💜

Parameters

_synchronized — this is not intended to be used directly. See new() (openstack.resource.Resource.new) and existing() (openstack.resource.Resource.existing). don't touch, fr fr 🙈
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.

resource_key = 'arq' : singular form of key for resource.

resources_key = 'arqs' : plural form of key for resource. yes, the s is doing all the work 🎀

base_path = '/accelerator_requests' : the base part of the URI for this resource.

create_opts = CreateOpts(request_key=None, response_key=<Unset.UNSET: 'UNSET'>, method='POST', requires_id=<Unset.UNSET: 'UNSET'>, response_has_body=True) : class-level configuration for the create operation. Subclasses can override this to set per-resource defaults without overriding create().

allow_create = True : allow create operation for this resource.

allow_fetch = True : allow get operation for this resource.

allow_delete = True : allow delete operation for this resource.

allow_list = True : allow list operation for this resource.

allow_patch = True : allow patch operation for binding.

attach_handle_info : the device address associated with this ARQ (if any)

attach_handle_type : the type of attach handle (e.g. PCI, mdev...)

device_profile_name : the name of the device profile

device_profile_group_id : the id of the device profile group

device_rp_uuid : the UUID of the bound device RP (if any)

hostname : the host name to which ARQ is bound. (if any)

instance_uuid : the UUID of the instance associated with this ARQ (if any)

state : the state of the ARQ

uuid : the UUID of the ARQ

`patch(session, patch=None, prepend_key=True, has_body=True, retry_on_conflict=None, base_path=None, *, microversion=None)`

Patch the remote resource. ✨

Lets you modify the resource by handing over a list of JSON patches to apply to it. The patches can use both the original (server-side) and SDK field names — flexible, we love to see it 💅

Parameters

session — the session to use for making this request.
patch — additional JSON patch as a list or one patch item. If provided, it is applied on top of any changes to the current resource.
prepend_key — whether the resource_key (openstack.resource.Resource.resource_key) should be prepended in a resource creation request. Default to True.
retry_on_conflict — whether to enable retries on HTTP CONFLICT (409). Value of None leaves the Adapter defaults.
base_path — base part of the URI for modifying resources, if different from base_path (openstack.resource.Resource.base_path).
microversion — the API version to override the negotiated one ✨

Returns 💖

This Resource instance, bestie. That's it. That's the return.

Raises MethodNotSupported if Resource.allow_patch is not set to True — like, it will literally throw hands if patching isn't allowed, so check that flag first, no cap 😭

openstack.accelerator.v2.attribute

✨ The Attribute Class ✨

The Attribute class inherits from Resource.

class openstack.accelerator.v2.attribute.Attribute(_synchronized=False, connection=None, **attrs)

The base resource 🫶

Parameters

_synchronized — okay so this one is not for direct use, bestie. Don't touch it. Go look at new() and existing() instead, that's the vibe 👑
connection — reference to the Connection being used. Defaults to None, and that's on purpose — it lets Resource objects exist without an active Connection, like in unit tests. And if you're using self._connection anywhere in Resource code, protect it with a None check, fr fr 💅

resource_key = 'attribute' Singular form of the key for this resource. One attribute. Just the one. 🎀

resources_key = 'attributes' Plural form of the key for this resource. Now we're talking multiples ✨

base_path = '/attributes' The base part of the URI for this resource — that's the URL chunk it lives at 🌸

allow_create = True Yes, you can create one of these 💖

allow_fetch = True Yes, you can fetch (get) one of these 🦋

allow_commit = False Nope, no update operation for this resource 🙈

allow_delete = True Yes, you can delete it 💀

allow_list = True Yes, you can list them all out, iconic behavior ⭐

created_at The timestamp when this attribute was created. Baby's birth certificate 🍼

deployable_id The deployable_id of the attribute.

key The key of the attribute.

value The value of the attribute.

updated_at The timestamp when this attribute was updated. Glow-up timestamp ✨

uuid The uuid of the attribute.

openstack.accelerator.v2.deployable

💜 The Deployable Class 💜

The Deployable class inherits from Resource.

class openstack.accelerator.v2.deployable.Deployable(_synchronized=False, connection=None, **attrs)

The base resource 🫶

Parameters

_synchronized — again, not for direct use. See new() and existing() instead, iykyk 👑
connection — reference to the Connection being used. Defaults to None so Resource objects can be used without an active Connection, like in unit tests. And use of self._connection in Resource code should protect itself with a check for None 💅

resource_key = 'deployable' Singular form of the key for this resource.

resources_key = 'deployables' Plural form of the key for this resource.

base_path = /deployables The base part of the URI for this resource 🌈

allow_create = False No create operation here, sorry bestie 🙈

allow_fetch = True Fetch? Yes. Get it, girl 💖

allow_commit = False No update operation. Not today 💀

allow_delete = False No delete operation either. Hands off 🚫

allow_list = True But you can list them, and that's the tea ⭐

allow_patch = True And you can patch. Patching is the whole main character energy of this class 🔥

created_at The timestamp when this deployable was created.

device_id The device_id of the deployable.

id The UUID of the deployable.

name The name of the deployable.

num_accelerators The num_accelerator of the deployable.

parent_id The parent_id of the deployable.

root_id The root_id of the deployable.

updated_at The timestamp when this deployable was updated.

patch(session, patch=None, prepend_key=True, has_body=True, retry_on_conflict=None, base_path='/deployables/%(id)s/program', *, microversion=None)

Patch the remote resource. 🩹✨

This lets you modify the resource by handing over a list of JSON patches to apply to it. And the patches can use both the original (server-side) field names and the SDK field names — flexible queen behavior, honestly 💅

Parameters

session — the session to use for making this request.
patch — additional JSON patch, as a list or one patch item. If you provide it, it gets applied on top of any changes to the current resource.
prepend_key — whether the resource_key should be prepended in a resource creation request. Defaults to True.
retry_on_conflict — whether to enable retries on HTTP CONFLICT (409). A value of None leaves the Adapter defaults alone, no notes 🎀
base_path — base part of the URI for modifying resources, if it's different from base_path. Note the default here is '/deployables/%(id)s/program', which is not the plain class-level one, so like... read it carefully bestie 👀
microversion — the API version to override the negotiated one.

Returns 💖

This Resource instance.

Raises MethodNotSupported if Resource.allow_patch is not set to True. (Spoiler: for this class it is True, so you're chilling 🌈)

openstack.accelerator.v2.device

🦋 The Device Class 🦋

The Device class inherits from Resource.

class openstack.accelerator.v2.device.Device(_synchronized=False, connection=None, **attrs)

The base resource 🫶

Parameters

_synchronized — not intended to be used directly, see new() and existing() instead ⭐
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None 💅

resource_key = 'device' Singular form of the key for this resource.

resources_key = 'devices' Plural form of the key for this resource.

base_path = /devices The base part of the URI for this resource 🌸

allow_create = False No creating devices here 🙈

allow_fetch = True Fetching? Absolutely, obsessed 💖

allow_commit = False No update operation 💀

allow_delete = False No delete operation 🚫

allow_list = True Listing is on the menu, periodt ⭐

created_at The timestamp when this device was created.

hostname The hostname of the device.

id The ID of the device.

model The model of the device.

status The status of the device.

std_board_info The std board information of the device.

type The type of the device.

updated_at The timestamp when this device was updated.

uuid The UUID of the device.

vendor The vendor ID of the device.

vendor_board_info The vendor board information of the device.

enable(session) Enable the device. Turn it all the way on 💅✨

disable(session) Disable the device. Okay, turn it back off 😭

openstack.accelerator.v2.device_profile

🎀 The DeviceProfile Class 🎀

The DeviceProfile class inherits from Resource.

class openstack.accelerator.v2.device_profile.DeviceProfile(_synchronized=False, connection=None, **attrs)

The base resource 🫶

Parameters

_synchronized — not intended for direct use, bestie. See new() and existing() 👑
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None 🦋

resource_key = 'device_profile' Singular form of the key for this resource.

resources_key = 'device_profiles' Plural form of the key for this resource.

base_path = /device_profiles The base part of the URI for this resource 🌈

allow_create = True You can create these, slay 💖

allow_fetch = True You can fetch these too ✨

allow_commit = False No update operation 💀

allow_delete = True Deletion is allowed, handle with care 🙈

allow_list = True And listing, obviously ⭐

created_at The timestamp when this device_profile was created.

description The description of the device profile.

groups The groups of the device profile.

name The name of the device profile.

updated_at The timestamp when this device_profile was updated.

uuid The uuid of the device profile.

create_opts — class-level config for the create operation, shaped like this:

create_opts = CreateOpts(request_key=None,
response_key=<Unset.UNSET: 'UNSET'>, method='POST',
requires_id=<Unset.UNSET: 'UNSET'>, response_has_body=True)

Subclasses can override this to set per-resource defaults without overriding create(). Slay, inheritance.

🦾 Baremetal Resources 🦾

`openstack.baremetal.v1.Allocation`

Bestie. The Allocation Class. It inherits from Resource (peep #openstack.resource.Resource).

class openstack.baremetal.v1.allocation.Allocation(_synchronized=False,
connection=None, **attrs)

The base resource 💅

Parameters

_synchronized — not intended to be used directly, ok? Look at new() (see #openstack.resource.Resource.new) and existing() (see #openstack.resource.Resource.existing) instead.
connection — reference to the Connection being used. Defaults to None so Resource objects can be used without an active Connection, like in unit tests. And fr, any use of self._connection inside Resource code should protect itself with a check for None.
resources_key = 'allocations' — the plural form of the key for this resource.
base_path = '/allocations' — the base part of the URI for this resource.
allow_create = True — create operation? allowed. 💖
allow_fetch = True — get operation? allowed.
allow_commit = True — update operation? allowed.
allow_delete = True — delete operation? allowed.
allow_list = True — list operation? allowed.
allow_patch = True — patch operation? allowed.
commit_method = 'PATCH' — the method for committing a resource. It must be PATCH if allow_patch is True. No cap.

Attributes, the main character lineup:

candidate_nodes — the candidate nodes for this allocation.
created_at — timestamp at which the allocation was created.
extra — a set of one or more arbitrary metadata key and value pairs.
id — the UUID for the allocation.
last_error — the last error for the allocation. 😭
links — a list of relative links, including the self and bookmark links.
name — the name of the allocation.
node — the node UUID or name to create the allocation against, bypassing the normal allocation process. Sneaky but valid.
node_id — UUID of the node this allocation belongs to.
owner — the tenant who owns the object.
resource_class — the requested resource class.
state — the state of the allocation.
traits — the requested traits.
updated_at — timestamp at which the allocation was last updated.

`wait(session, timeout=None, ignore_error=False)`

Wait for the allocation to become active. The suspense… 🫶

Parameters

session — the session to use for making this request.
timeout — how much (in seconds) to wait for the allocation. A value of None (the default) means no client-side timeout, so like, buckle up.
ignore_error — if True, this call will raise an exception if the allocation reaches the error state. Otherwise the error state is considered successful and the call returns.

Returns — this Allocation instance. 🎀

Raises ResourceFailure (see #openstack.exceptions.ResourceFailure) if allocation fails and ignore_error is False.

Raises ResourceTimeout (see #openstack.exceptions.ResourceTimeout) on timeout. 💀

`openstack.baremetal.v1.chassis`

The Chassis Class, bestie. Inherits from Resource (see #openstack.resource.Resource).

class openstack.baremetal.v1.chassis.Chassis(_synchronized=False,
connection=None, **attrs)

The base resource ✨

Parameters

_synchronized — not intended to be used directly. See new() (#openstack.resource.Resource.new) and existing() (#openstack.resource.Resource.existing).
connection — reference to the Connection being used. Defaults to None so Resource objects work without an active Connection, like in unit tests. Use of self._connection in Resource code should protect itself with a check for None.
resources_key = 'chassis' — plural form of key for resource.
base_path = '/chassis' — the base part of the URI for this resource.
allow_create = True — allow create operation for this resource.
allow_fetch = True — allow get operation for this resource.
allow_commit = True — allow update operation for this resource.
allow_delete = True — allow delete operation for this resource.
allow_list = True — allow list operation for this resource.
allow_patch = True — allow patch operation for this resource.
commit_method = 'PATCH' — method for committing a resource. Must be PATCH if allow_patch is True. Periodt.

Attributes:

created_at — timestamp at which the chassis was created.
description — a descriptive text about the service.
extra — a set of one or more arbitrary metadata key and value pairs.
id — the UUID for the chassis.
links — a list of relative links, including the self and bookmark links.
nodes — links to the collection of nodes contained in the chassis.
updated_at — timestamp at which the chassis was last updated.

`openstack.baremetal.v1.conductor`

The Conductor Class. Inherits from Resource (see #openstack.resource.Resource). 🌈

class openstack.baremetal.v1.conductor.Conductor(_synchronized=False,
connection=None, **attrs)

The base resource 🌸

Parameters

_synchronized — not intended to be used directly, see new() (#openstack.resource.Resource.new) and existing() (#openstack.resource.Resource.existing).
connection — reference to the Connection being used. Defaults to None so Resource objects can be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.
resources_key = 'conductors' — plural form of key for resource.
base_path = '/conductors' — the base part of the URI for this resource.
allow_create = False — no creating, bestie. 🚫
allow_fetch = True — get operation allowed.
allow_commit = False — no updating.
allow_delete = False — no deleting.
allow_list = True — listing? absolutely, go off.
allow_patch = False — and no patching either.

`openstack.baremetal.v1.deploy_templates`

The DeployTemplate Class. Inherits from Resource (see #openstack.resource.Resource).

class openstack.baremetal.v1.deploy_templates.DeployTemplate(_synchronized=False,
connection=None, **attrs)

The base resource 💜

Parameters

_synchronized — not intended to be used directly. See new() (#openstack.resource.Resource.new) and existing() (#openstack.resource.Resource.existing).
connection — reference to the Connection being used. Defaults to None so Resource objects can be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.
resources_key = 'deploy_templates' — plural form of key for resource.
base_path = '/deploy_templates' — the base part of the URI for this resource.
allow_create = True — allow create operation for this resource.
allow_fetch = True — allow get operation for this resource.
allow_commit = True — allow update operation for this resource.
allow_delete = True — allow delete operation for this resource.
allow_list = True — allow list operation for this resource.
allow_patch = True — allow patch operation for this resource.
commit_method = 'PATCH' — method for committing a resource. This must be PATCH if allow_patch is True.

Attributes:

name — the name of this resource.
created_at — timestamp at which the deploy_template was created.
extra — a set of one or more arbitrary metadata key and value pairs.
links — a list of relative links. Includes the self and bookmark links.
steps — a set of physical information of the deploy_template. 🦋
updated_at — timestamp at which the deploy_template was last updated.
id — the UUID of the resource.

`openstack.baremetal.v1.driver`

The Driver Class. Inherits from Resource (see #openstack.resource.Resource). 🏎️

class openstack.baremetal.v1.driver.Driver(_synchronized=False,
connection=None, **attrs)

The base resource 👑

Parameters

_synchronized — this is not intended to be used directly, ok? See new() (#openstack.resource.Resource.new) and existing() (#openstack.resource.Resource.existing).
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.
connection — a reference to the Connection that's being used. Defaults to None so Resource objects can exist without an active Connection — like in unit tests, bestie 💅. And fr fr: if you're poking at self._connection inside Resource code, guard it with a None check. No cap.

resources_key = 'drivers' — the plural form of the key for this resource. Slay, pluralization.

base_path = '/drivers' — the base part of the URI for this resource. It's giving URL starter pack ✨

allow_create = False — nope, no create operation for this resource.

allow_fetch = True — yes, get operation? Allowed 🫶

allow_commit = False — update operation? Not here, babe.

allow_delete = False — delete? Also no 🙈

allow_list = True — list operation? Absolutely, we stan a listable resource 👑

hosts — a list of active hosts that support this driver.

links — a list of relative links, including the self and bookmark links.

name — the name of the driver.

properties — a list of links to driver properties.

default_bios_interface — default BIOS interface implementation. Introduced in API microversion 1.40.

default_boot_interface — default boot interface implementation. Introduced in API microversion 1.30.

default_console_interface — default console interface implementation. Introduced in API microversion 1.30.

default_deploy_interface — default deploy interface implementation. Introduced in API microversion 1.30.

default_firmware_interface — default firmware interface implementation. Introduced in API microversion 1.86.

default_inspect_interface — default inspect interface implementation. Introduced in API microversion 1.30.

default_management_interface — default management interface implementation. Introduced in API microversion 1.30.

default_network_interface — default network interface implementation. Introduced in API microversion 1.30.

default_power_interface — default port interface implementation. Introduced in API microversion 1.30. (yes, it says port — that's the manpage talking, not me 😭)

default_raid_interface — default RAID interface implementation. Introduced in API microversion 1.30.

default_rescue_interface — default rescue interface implementation. Introduced in API microversion 1.38.

default_storage_interface — default storage interface implementation. Introduced in API microversion 1.33.

default_vendor_interface — default vendor interface implementation. Introduced in API microversion 1.30.

enabled_bios_interfaces — enabled BIOS interface implementations. Introduced in API microversion 1.40.

enabled_boot_interfaces — enabled boot interface implementations. Introduced in API microversion 1.30.

enabled_console_interfaces — enabled console interface implementations. Introduced in API microversion 1.30.

enabled_deploy_interfaces — enabled deploy interface implementations. Introduced in API microversion 1.30.

enabled_firmware_interfaces — enabled firmware interface implementations. Introduced in API microversion 1.86.

enabled_inspect_interfaces — enabled inspect interface implementations. Introduced in API microversion 1.30.

enabled_management_interfaces — enabled management interface implementations. Introduced in API microversion 1.30.

enabled_network_interfaces — enabled network interface implementations. Introduced in API microversion 1.30.

enabled_power_interfaces — enabled port interface implementations. Introduced in API microversion 1.30. (again with the port, iykyk 🫠)

enabled_raid_interfaces — enabled RAID interface implementations. Introduced in API microversion 1.30.

enabled_rescue_interfaces — enabled rescue interface implementations. Introduced in API microversion 1.38.

enabled_storage_interfaces — enabled storage interface implementations. Introduced in API microversion 1.33.

enabled_vendor_interfaces — enabled vendor interface implementations. Introduced in API microversion 1.30.

list_vendor_passthru(session) — fetch the vendor specific methods that this driver exposes 💖

Parameters
- session — the session to use for making this request.
Returns — a dict of the available vendor passthru methods for the driver. Method names are the keys, and corresponding usages in dict form are the values. Usage dict properties:
- async: bool # Is passthru function invoked asynchronously
- attach: bool # Is return value attached to response object
- description: str # Description of what the method does
- http_methods: list # List of HTTP methods supported

call_vendor_passthru(session, verb, method, body=None) — call a vendor specific passthru method 🎀

Contents of body are params passed to the hardware driver function. Validation happens there — so if parameters are missing, or if there are excess parameters, the request gets rejected. Periodt.

Parameters
- session — the session to use for making this request.
- method — vendor passthru method name.
- verb — one of GET, POST, PUT, or DELETE, depending on the driver and method.
- body — passed to the vendor function as json body.
Raises — ValueError if verb is not one of GET, POST, PUT, DELETE.
Returns — response of method call.

🦋 `openstack.baremetal.v1.inspection_rules` 🦋

The `InspectionRule` Class 💜

The InspectionRule class inherits from Resource <#openstack.resource.Resource>.

class openstack.baremetal.v1.inspection_rules.InspectionRule(_synchronized=False, connection=None, **attrs)

The base resource.

Parameters
- _synchronized — this is not intended to be used directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
- connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.

resources_key = 'inspection_rules' — plural form of key for resource. (Ik it's long, it's fine, we love her 🌸)

base_path = '/inspection_rules' — the base part of the URI for this resource.

allow_create = True — allow create operation for this resource.

allow_fetch = True — allow get operation for this resource.

allow_commit = True — allow update operation for this resource.

allow_delete = True — allow delete operation for this resource.

allow_list = True — allow list operation for this resource.

allow_patch = True — allow patch operation for this resource.

commit_method = 'PATCH' — method for committing a resource. This must be PATCH if allow_patch is True. Like, mandatory mandatory 💀

actions — the actions to be executed when the rule conditions are met.

description — a brief explanation about the inspection rule.

conditions — the conditions under which the rule should be triggered.

created_at — timestamp at which the resource was created.

links — a list of relative links. Includes the self and bookmark links.

phase — specifies the phase when the rule should run, defaults to 'main'. Main character energy, literally ✨

priority — specifies the rule's precedence level during execution.

sensitive — indicates whether the rule contains sensitive information. 🙈

updated_at — timestamp at which the resource was last updated.

id — the UUID of the resource.

🌈 `openstack.baremetal.v1.Node` 🌈

The `Node` Class 👑

The Node class inherits from Resource <#openstack.resource.Resource>.

class openstack.baremetal.v1.node.Node(_synchronized=False, connection=None, **attrs)

The base resource.

Parameters
- _synchronized — this is not intended to be used directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
- connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.

resources_key = 'nodes' — plural form of key for resource.

base_path = '/nodes' — the base part of the URI for this resource.

allow_create = True — allow create operation for this resource.

allow_fetch = True — allow get operation for this resource.

allow_commit = True — allow update operation for this resource.

allow_delete = True — allow delete operation for this resource.

allow_list = True — allow list operation for this resource.

and bestie, we're not even done yet — more Node goodness incoming 💅

allow_patch = True — Allow patch operation for this resource.
commit_method = 'PATCH' — Method for committing a resource. This must be PATCH if allow_patch is True.

🖤 the node fields, one by one

okay bestie, this is the long one — every attribute of a baremetal node, plus exactly which microversion it showed up in. no skipping, i promise 🫶

allocation_id — The UUID of the allocation associated with this node. Added in API microversion 1.52.
owner — A string or UUID of the tenant who owns the baremetal node. Added in API microversion 1.50.
boot_mode — The current boot mode state (uefi/bios). Added in API microversion 1.75.
chassis_id — The UUID of the chassis associated with this node. Can be empty or None. 💀
clean_step — The current clean step.
conductor_group — Conductor group this node is managed by. Added in API microversion 1.46.
created_at — Timestamp at which the node was last updated. (yes, that's what it says, we don't make the rules 💅)
deploy_step — The current deploy step. Added in API microversion 1.44.
description — The description of the node. Added in API microversion 1.51.
driver — The name of the driver.
driver_info — All the metadata required by the driver to manage this node. List of fields varies between drivers, and can be retrieved from the openstack.baremetal.v1.driver.Driver <#openstack.baremetal.v1.driver.Driver> resource.
driver_internal_info — Internal metadata set and stored by node's driver. This is read-only. 🔒
extra — A set of one or more arbitrary metadata key and value pairs.
fault — Fault type that caused the node to enter maintenance mode. Introduced in API microversion 1.42.
health — The health status of the node from the BMC (e.g. 'OK', 'Warning', 'Critical'). Introduced in API microversion 1.109.
id — The UUID of the node resource.
instance_info — Information used to customize the deployed image, e.g. size of root partition, config drive in the form of base64 encoded string and other metadata.
instance_id — UUID of the nova instance associated with this node.
instance_name — The name of the instance associated with this node. Added in API microversion 1.104.
is_automated_clean_enabled — Override enabling of automated cleaning. Added in API microversion 1.47.
is_console_enabled — Whether console access is enabled on this node.
is_maintenance — Whether node is currently in "maintenance mode". Nodes put into maintenance mode are removed from the available resource pool. 🙈
is_retired — Whether the node is marked for retirement. Added in API microversion 1.61.
is_secure_boot — Whether the node is currently booted with secure boot turned on. Added in API microversion 1.75.
last_error — Any error from the most recent transaction that started but failed to finish. 😭
lessee — Field indicating if the node is leased to a specific project. Added in API version 1.65
links — A list of relative links, including self and bookmark links.
maintenance_reason — user settable description of the reason why the node was placed into maintenance mode.
name — Human readable identifier for the node. May be undefined. Certain words are reserved. Added in API microversion 1.5
parent_node — The node which serves as the parent_node for this node. Added in API version 1.83
ports — Links to the collection of ports on this node.
port_groups — Links to the collection of portgroups on this node. Available since API microversion 1.24.
power_state — The current power state. Usually "power on" or "power off", but may be "None" if service is unable to determine the power state.
properties — Physical characteristics of the node. Content populated by the service during inspection.
provision_state — The current provisioning state of the node.
retired_reason — The reason why the node is marked for retirement. Added in API microversion 1.61.
raid_config — The current RAID configuration of the node.
reservation — The name of an service conductor host which is holding a lock on this node, if a lock is held.
resource_class — A string to be used by external schedulers to identify this node as a unit of a specific type of resource. Added in API microversion 1.21.
service_step — A string representing the current service step being executed upon. Added in API microversion 1.89.
runbook — A string representing the uuid or logical name of a runbook as an alternative to providing clean_steps or service_steps. Added in API microversion 1.92.
shard — A string indicating the shard this node belongs to. Added in API microversion 1,82. (that comma is canon, i don't make the rules 🫠)
states — Links to the collection of states.
target_provision_state — The requested state if a provisioning action has been requested. For example, AVAILABLE, DEPLOYING, DEPLOYWAIT, DEPLOYING, ACTIVE etc.
target_power_state — The requested state during a state transition.
target_raid_config — The requested RAID configuration of the node which will be applied when the node next transitions through the CLEANING state.
traits — Traits of the node. Introduced in API microversion 1.37.
updated_at — Timestamp at which the node was last updated.

🧚 the interfaces, aka the plug-in slots

these are all "which thingy do we use for X" fields, and yep, every single one has its own microversion. iconic behaviour honestly ✨

bios_interface — BIOS interface to use when setting BIOS properties of the node. Introduced in API microversion 1.40.
boot_interface — Boot interface to use when configuring boot of the node. Introduced in API microversion 1.31.
console_interface — Console interface to use when working with serial console. Introduced in API microversion 1.31.
deploy_interface — Deploy interface to use when deploying the node. Introduced in API microversion 1.31.
firmware_interface — Firmware interface to be used when managing the node. Introduced in API microversion 1.86
inspect_interface — Inspect interface to use when inspecting the node. Introduced in API microversion 1.31.
management_interface — Management interface to use for management actions on the node. Introduced in API microversion 1.31.
network_interface — Network interface provider to use when plumbing the network connections for this node. Introduced in API microversion 1.20.
power_interface — Power interface to use for power actions on the node. Introduced in API microversion 1.31.
raid_interface — RAID interface to use for configuring RAID on the node. Introduced in API microversion 1.31.
rescue_interface — Rescue interface to use for rescuing of the node. Introduced in API microversion 1.38.
storage_interface — Storage interface to use when attaching remote storage. Introduced in API microversion 1.33.
vendor_interface — Vendor interface to use for vendor-specific actions on the node. Introduced in API microversion 1.31.

🌈 `create(session, prepend_key=True, base_path=None, *, microversion=None, **params)`

Create a remote resource based on this instance. 🫶

The overridden version is capable of handling the populated provision_state field of one of three values: enroll, manageable or available. If not provided, the server default is used (enroll in newer versions of Ironic).

This call does not cause a node to go through automated cleaning. If you need it, use provision_state=manageable followed by a call to set_provision_state(). 🧼

Note that Bare Metal API 1.4 is required for manageable and 1.11 is required for enroll.

⚠️ Warning: Using provision_state=available is only possible with API versions 1.1 to 1.10 and thus is incompatible with setting any fields that appeared after 1.11. like, genuinely don't do it bestie 💀

Parameters

session — The session to use for making this request.

Returns

This Resource instance.

Raises

ValueError if the Node's provision_state is not one of None, enroll, manageable or available.
NotSupported <#openstack.exceptions.NotSupported> if the provision_state cannot be reached with any API version supported by the server.

🎀 `commit(session, *args, **kwargs)`

Commit the state of the instance to the remote resource.

Parameters

session — The session to use for making this request.

Returns

This Node instance.

👑 `set_provision_state(session, target, config_drive=None, clean_steps=None, rescue_password=None, wait=False, timeout=None, deploy_steps=None, service_steps=None, runbook=None)`

Run an action modifying this node's provision state.

This call is asynchronous — it will return success as soon as the Bare Metal service acknowledges the request. so like, don't assume it's done just because it replied, okay? ⭐

Parameters

session — the session you're using to make this request, bestie. yeah, every single one of these needs it.
target — the provisioning action you want, like active or provide. check the Bare Metal service docs for the full list of actions that exist, okay? ✨
config_drive — the config drive you're passing to the node. only valid for active and rebuild targets, lowkey. you can build one using functions from openstack.baremetal.configdrive 🎀
clean_steps — the clean steps to execute. only valid for the clean target.
rescue_password — password for the rescue operation. only valid for the rescue target 🔥
wait — whether to actually wait for the target state to be reached or just vibe and dip.
timeout — timeout (in seconds) to wait for the target state to be reached. if it's None, you wait forever, no timeout, no cap, we die like legends 💀
deploy_steps — deploy steps to execute. only valid for active and rebuild targets.
service_steps — service steps to execute. only valid for the service target.
runbook — the UUID or logical name of a runbook.

Returns This Node instance. your node, your bestie, returned to you 🫶

Raises ValueError if config_drive, clean_steps, deploy_steps or rescue_password are provided with an invalid target. like, don't do that.

Raises ResourceFailure <#openstack.exceptions.ResourceFailure> if the node reaches an error state while waiting for the state. 😭

Raises ResourceTimeout <#openstack.exceptions.ResourceTimeout> if timeout is reached while waiting for the state.

`wait_for_power_state(session, expected_state, timeout=None)`

wait for the node to reach the expected power state. literally just sitting there refreshing until it happens ⭐

Parameters

session — the session to use for making this request.
expected_state — the expected power state you want it to reach.
timeout — if wait is set to True, this specifies how much (in seconds) to wait for the expected state to be reached. the value None (the default) means no client-side timeout. no cap, infinite patience 🧚

Returns This Node instance.

Raises ResourceTimeout <#openstack.exceptions.ResourceTimeout> on timeout.

`wait_for_provision_state(session, expected_state, timeout=None, abort_on_failed_state=True)`

wait for the node to reach the expected state. provision-state edition 💅

Parameters

session — the session to use for making this request.
expected_state — the expected provisioning state you want it to reach.
timeout — if wait is set to True, this specifies how much (in seconds) to wait for the expected state to be reached. the value None (the default) means no client-side timeout.
abort_on_failed_state — if True (the default), it aborts waiting if the node reaches a failure state which does not match the expected one. heads up though: the failure state for the enroll -> manageable transition is enroll again. yes really, that's the rule 🙈

Returns This Node instance.

Raises ResourceFailure <#openstack.exceptions.ResourceFailure> if the node reaches an error state and abort_on_failed_state is True.

Raises ResourceTimeout <#openstack.exceptions.ResourceTimeout> on timeout.

`wait_for_reservation(session, timeout=None)`

wait for a lock on the node to be released. we're waiting for the node to be free, basically 💖

bare metal nodes in ironic have a reservation lock. it's used to represent that a conductor has locked the node while performing some sort of action — like changing configuration as a result of a machine state change. main character conductor energy, honestly 👑

this lock can occur during power syncronization, and it prevents updates to objects attached to the node, such as ports. so like, no touching while it's locked, okay?

heads up bestie: nothing prevents a conductor from acquiring the lock again after this call returns, so treat it as best effort. it's giving "I'll try my best" not "guaranteed" 😭

it returns immediately if there is no reservation on the node. slay, no waiting needed 💅

Parameters

session — the session to use for making this request.
timeout — how much (in seconds) to wait for the lock to be released. the value None (the default) means no timeout.

Returns This Node instance.

`inject_nmi(session)`

inject NMI. that's it. that's the whole thing 🔥

Parameters session — the session to use for making this request.

Returns None

`set_power_state(session, target, wait=False, timeout=None)`

run an action modifying this node's power state ⚡

this call is asynchronous, so it returns success as soon as the Bare Metal service acknowledges the request. it doesn't mean the thing is done, bestie, it means they heard you 📣

Parameters

session — the session to use for making this request.
target — target power state, as a PowerAction or a string.
wait — whether to wait for the expected power state to be reached.
timeout — timeout (in seconds) to wait for the target state to be reached. if None, wait without timeout.

`attach_vmedia(session, device_type, image_url, image_download_source=None, retry_on_conflict=True)`

attach a virtual media device to a node 🎀

Parameters

session — the session to use for making this request.
device_type — the type of virtual media device.
image_url — the URL of the image to attach.
image_download_source — the source of the image download.
retry_on_conflict — whether to retry HTTP CONFLICT errors. this can happen when either the virtual media is already used on a node or the node is locked. since the latter happens more often, the default value is True. lowkey relatable, the node is always locked 🔒

Returns None

Raises NotSupported <#openstack.exceptions.NotSupported> if the server does not support the VMEDIA API. rude of the server, honestly.

`detach_vmedia(session, device_types=None)`

detach virtual media from a node. bye bye virtual media 👋

Parameters

session — the session to use for making this request.
device_types — a list with the types of virtual media devices to detach.

Returns True if the virtual media was detached, otherwise False.

Raises NotSupported <#openstack.exceptions.NotSupported> if the server does not support the VMEDIA API

`attach_vif(session, vif_id, retry_on_conflict=True, *, port_id=None, port_group_id=None)`

attach a VIF to the node 🌈

the exact form of the VIF ID depends on the network interface used by the node. in the most common case it's a Network service port (NOT a Bare Metal port) ID — read that again, bestie, NOT a bare metal port. a VIF can only be attached to one node at a time, no sharing ✋

Parameters

session — the session to use for making this request.
vif_id — backend-specific VIF ID.
retry_on_conflict — whether to retry HTTP CONFLICT errors. this can happen when either the VIF is already used on a node or the node is locked. since the latter happens more often, the default value is True.
port_id — the UUID of the port to attach the VIF to. only one of port_id or port_group_id can be provided, pick one 💅
port_group_id — the UUID of the portgroup to attach to. only one of port_group_id or port_id can be provided. same deal, one or the other.

Returns None

Raises NotSupported <#openstack.exceptions.NotSupported> if the server does not support the VIF API.

Raises InvalidRequest <#openstack.exceptions.InvalidRequest> if both port_id and port_group_id are provided. like, you can't have both, that's the whole point 😤

`detach_vif(session, vif_id, ignore_missing=True)`

detach a VIF from the node 🦋

the exact form of the VIF ID depends on the network interface used by the node. in the most common case it's a Network service port (NOT a Bare Metal port) ID. yeah, same warning as attach, it matters both ways 💜

Parameters

session — the session to use for making this request.
vif_id — backend-specific VIF ID.
ignore_missing — when set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the VIF does not exist. otherwise, False is returned. basically: do you want drama or do you want peace? 🙈

Returns True if the VIF was detached, otherwise False.

Raises NotSupported (that's openstack.exceptions.NotSupported) if the server doesn't support the VIF API. Like, it's literally just not a thing on that server, bestie, don't take it personally 💅

`list_vifs(session)`

Ok so this one lists the IDs of all the VIFs attached to the node ✨

Heads up tho: the exact form of the VIF ID depends on whatever network interface the node is using. In the most common case it's a Network service port (and NOT a Bare Metal port) ID. Iykyk 🫶

session — the session you're using to make this request.

Returns — a list of VIF IDs, as strings 🌸

Raises NotSupported (openstack.exceptions.NotSupported) if the server doesn't support the VIF API.

`validate(session, required=('boot', 'deploy', 'power'))`

Validate the required info on the node. Vibe check for your node, basically 👑

session — the session you're using to make this request.
required — list of interfaces that are required to pass validation. The default value is the list of minimum required interfaces for provisioning (that's ('boot', 'deploy', 'power'), iconically).

Returns — a dict mapping interface names to ValidationResult objects ⭐

Raises ValidationException (openstack.exceptions.ValidationException) if validation fails for a required interface. Not the vibe. 😭

`set_maintenance(session, reason=None)`

Turns maintenance mode on for the node. It's giving "do not disturb" 🚧

session — the session you're using to make this request.
reason — optional reason for maintenance. Tell them why, bestie.

Returns — this Node instance 💖

`unset_maintenance(session)`

Turns maintenance mode off for the node. Back online, main character energy ✨

session — the session you're using to make this request.

Returns — this Node instance 💖

`get_boot_device(session)`

Gets the node's boot device. Which thing is it booting from, fr fr 🥾

session — the session you're using to make this request.

Returns — the HTTP response.

`set_boot_device(session, boot_device, persistent=False)`

Sets the node's boot device 🔥

session — the session you're using to make this request.
boot_device — the boot device to assign to the node.
persistent — if the boot device change is maintained after the node reboots. Defaults to False, so it's a temporary slay unless you say otherwise.

Returns — None

`get_supported_boot_devices(session)`

Gets the boot devices that are supported for the node. The menu of options 🍓

session — the session you're using to make this request.

Returns — the HTTP response.

`set_boot_mode(session, target)`

Makes a request to change the node's boot mode 🦋

This call is asynchronous — it returns success as soon as the Bare Metal service acknowledges the request. So like, it said "yes bestie" but the actual work is still happening in the background, ngl.

session — the session you're using to make this request.
target — the boot mode to set for the node, one of either 'uefi' or 'bios'.

Returns — None

Raises ValueError if target is not one of 'uefi' or 'bios'.

`set_secure_boot(session, target)`

Makes a request to change the node's secure boot state 🔐

Same deal as above — this call is asynchronous, and it returns success as soon as the Bare Metal service acknowledges the request. The service is doing its thing, ok? 🙈

session — the session you're using to make this request.
target — a boolean indicating the secure boot state to set. True/False correspond to 'on'/'off' respectively.

Returns — None

Raises ValueError if target is not boolean.

`add_trait(session, trait)`

Adds a trait to the node. Giving it a little accessory 🎀

session — the session you're using to make this request.
trait — the trait to add to the node.

Returns — None

`remove_trait(session, trait, ignore_missing=True)`

Removes a trait from the node. Accessory off, we're moving on 💅

session — the session you're using to make this request.
trait — the trait to remove from the node.
ignore_missing — when set to False, NotFoundException (openstack.exceptions.NotFoundException) will be raised when the trait doesn't exist. Otherwise, False is returned. Default is True, so by default it's chill about it.

Returns bool — True on successfully removing the trait. False when the trait doesn't exist already.

`set_traits(session, traits)`

Sets traits for the node 🌈

It removes any existing traits and then adds the traits you passed in to this method. So like, it's a full reset, not a merge — no cap.

session — the session you're using to make this request.
traits — list of traits to add to the node.

Returns — None

`call_vendor_passthru(session, verb, method, body=None)`

Calls a vendor passthru method. Fancy driver-specific stuff 👑

session — the session you're using to make this request.
verb — the HTTP verb, one of GET, POST, PUT, DELETE.
method — the method to call using vendor_passthru.
body — the JSON body in the HTTP call.

Returns — the HTTP response.

Raises ValueError if verb is not one of GET, POST, PUT, DELETE

`list_vendor_passthru(session)`

Lists the vendor passthru methods for the node 📋

session — the session you're using to make this request.

Returns — the HTTP response.

`get_console(session)`

Gets the node console. Peek at what's happening inside 🖥️

session — the session you're using to make this request.

Returns — the HTTP response.

`set_console_mode(session, enabled)`

Sets the node console mode 🎛️

session — the session you're using to make this request.
enabled — whether the console should be enabled or not.

Returns — None

`get_node_inventory(session, node_id=None)`

Gets a node's inventory. All the deets about the hardware ✨

session — the session you're using to make this request.
node_id — DEPRECATED The ID of the node. Yeah it's deprecated, don't come for me, it's still documented 💀

Returns — the HTTP response.

`list_firmware(session)`

Lists the firmware components associated with the node 🔧

session — the session you're using to make this request.

Returns — the HTTP response.

`patch(session, patch=None, prepend_key=True, has_body=True, retry_on_conflict=None, base_path=None, *, microversion=None, reset_interfaces=None)`

Patches the remote resource 🩹

This lets you modify the resource by providing a list of JSON patches to apply to it. The patches can use both the original (server-side) and SDK field names — flexible, we love that.

session — the session you're using to make this request.
patch — additional JSON patch, as a list or one patch item. If provided, it's applied on top of any changes to the current resource.
prepend_key — whether the resource_key (openstack.resource.Resource.resource_key) should be prepended in a resource creation request. Defaults to True.
retry_on_conflict — whether to enable retries on HTTP CONFLICT (409). A value of None leaves the Adapter defaults alone.
base_path — the base part of the URI for modifying resources, if it's different from base_path (openstack.resource.Resource.base_path).
microversion — API version to override the negotiated one.
reset_interfaces — yes this parameter is in the signature, and no, the original doesn't describe it. We're just acknowledging its existence respectfully 🫶

Returns — this Resource instance.

Raises MethodNotSupported (openstack.exceptions.MethodNotSupported) if Resource.allow_patch is not set to True. So like, if the resource didn't opt in, it's a no. 🙅‍♀️

🎀 The `PowerAction` Class 🎀

The PowerAction enumeration represents known power actions. Think of it as the official list of ways to tell a node to move 💅

class `openstack.baremetal.v1.node.PowerAction(*values)`

A mapping from an action to a target power state ✨

POWER_ON = 'power on' — power on the node. Wake up babe 🌞
POWER_OFF = 'power off' — power off the node (using hard power off). Brutal but effective 💀
REBOOT = 'rebooting' — reboot the node (using hard power off). Off and back on again 🔄
SOFT_POWER_OFF = 'soft power off' — power off the node using soft power off. The gentle version 🧚
SOFT_REBOOT = 'soft rebooting' — reboot the node using soft power off. Still gentle, still rebooting 🌸

💖 The ValidationResult Class

okay so ValidationResult is literally just the receipt 🧾 of a validation — it holds how that check went.

class openstack.baremetal.v1.node.ValidationResult(result, reason)

Result of a single interface validation. yes bestie, one interface at a time 💅

Variables (these are the whole personality of the class ✨):

result — the outcome of a validation: True means slay (success), False means nope (failure), and None means that interface isn't even supported, don't @ me.
reason — if result is False or None, this is the explanation of why. the receipts, basically 🙈

🦋 The WaitResult Class

WaitResult is the group-chat poll result of waiting on a whole squad of nodes.

class openstack.baremetal.v1.node.WaitResult(success, failure, timeout)

A named tuple representing a result of waiting for several nodes. 📋

Each component is a list of Node objects:

Variables:

~.success — a list of Node objects that reached the state. they made it, periodt 👑
~.timeout — a list of Node objects that reached timeout. they were still "omw" 😭
~.failure — a list of Node objects that hit a failure. not the vibe 💀

Create new instance of WaitResult(success, failure, timeout)

🎀 openstack.baremetal.v1.port

The Port Class

The Port class inherits from Resource <#openstack.resource.Resource>. it's giving very much "networking icon" energy 🔌

class openstack.baremetal.v1.port.Port(_synchronized=False, connection=None, **attrs)

The base resource.

Parameters:

_synchronized — ok so this is not intended to be used directly 🙅‍♀️. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
connection — Reference to the Connection being used. Defaults to None so that Resource objects can be used without an active Connection, like in unit tests, bestie. Any use of self._connection in Resource code should protect itself with a check for None. safety first ✨
resources_key = 'ports' — Plural form of key for resource.
base_path = '/ports' — The base part of the URI for this resource.
allow_create = True — Allow create operation for this resource.
allow_fetch = True — Allow get operation for this resource.
allow_commit = True — Allow update operation for this resource.
allow_delete = True — Allow delete operation for this resource.
allow_list = True — Allow list operation for this resource.
allow_patch = True — Allow patch operation for this resource.
commit_method = 'PATCH' — Method for committing a resource. This must be PATCH if allow_patch is True. no substitutions 🔥
address — The physical hardware address of the network port, typically the hardware MAC address. 🏷️
category — The category for the port.
created_at — Timestamp at which the port was created. ⏰
description — The description for the port.
extra — A set of one or more arbitrary metadata key and value pairs.
id — The UUID of the port.
internal_info — Internal metadata set and stored by the port. This field is read-only. Added in API microversion 1.18. 🙈
is_pxe_enabled — Whether PXE is enabled on the port. Added in API microversion 1.19.
is_smartnic — Whether the port is a Smart NIC port. Added in API microversion 1.53.
links — A list of relative links, including the self and bookmark links.
local_link_connection — The port bindig profile (yes, "bindig", that's how the source says it, i don't make the rules 😭). If specified, must contain switch_id and port_id fields. switch_info field is an optional string field to be used to store vendor specific information. Added in API microversion 1.19.
name — The name of the port.
node_id — The UUID of node this port belongs to.
physical_network — The name of physical network this port is attached to. Added in API microversion 1.34.
port_group_id — The UUID of PortGroup this port belongs to. Added in API microversion 1.24.
updated_at — Timestamp at which the port was last updated.
vendor — The vendor for the port.

🌸 openstack.baremetal.v1.port_group

The PortGroup Class

The PortGroup class inherits from Resource <#openstack.resource.Resource>. it's the friend group, and the ports are the members 🫶

class openstack.baremetal.v1.port_group.PortGroup(_synchronized=False, connection=None, **attrs)

The base resource.

Parameters:

_synchronized — This is not intended to be used directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
connection — Reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.
resources_key = 'portgroups' — Plural form of key for resource.
base_path = '/portgroups' — The base part of the URI for this resource.
allow_create = True — Allow create operation for this resource.
allow_fetch = True — Allow get operation for this resource.
allow_commit = True — Allow update operation for this resource.
allow_delete = True — Allow delete operation for this resource.
allow_list = True — Allow list operation for this resource.
allow_patch = True — Allow patch operation for this resource.
commit_method = 'PATCH' — Method for committing a resource. This must be PATCH if allow_patch is True.
address — The physical hardware address of the portgroup, typically the hardware MAC address. Added in API microversion 1.23.
created_at — Timestamp at which the portgroup was created. ⏰
extra — A set of one or more arbitrary metadata key and value pairs.
name — The name of the portgroup.
id — The UUID for the portgroup.
internal_info — Internal metadaa set and stored by the portgroup (yep, "metadaa" — typos stay, i don't fix the source, i just vibe check it 💀).
is_standalone_ports_supported — Whether ports that are members of this portgroup can be used as standalone ports. Added in API microversion 1.23.
links — A list of relative links, including the self and bookmark links.
mode — Port bonding mode. Added in API microversion 1.26.
node_id — UUID of the node this portgroup belongs to.
ports — A list of links to the collection of ports belonging to this portgroup. Added in API microversion 1.24.
properties — Port group properties. Added in API microversion 1.26.
updated_at — Timestamp at which the portgroup was last updated.

🧚 openstack.baremetal.v1.runbooks

The Runbook Class

The Runbook class inherits from Resource <#openstack.resource.Resource>. main character energy for automation steps 👑

class openstack.baremetal.v1.runbooks.Runbook(_synchronized=False, connection=None, **attrs)

The base resource.

Parameters:

_synchronized — This is not intended to be used directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
connection — Reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.
resources_key = 'runbooks' — Plural form of key for resource.
base_path = '/runbooks' — The base part of the URI for this resource.
allow_create = True — Allow create operation for this resource.
allow_fetch = True — Allow get operation for this resource.
allow_commit = True — Allow update operation for this resource.
allow_delete = True — Allow delete operation for this resource.
allow_list = True — Allow list operation for this resource.
allow_patch = True — Allow patch operation for this resource.
commit_method = 'PATCH' — Method for committing a resource. This must be PATCH if allow_patch is True.
name — The name of this resource.
created_at — Timestamp at which the runbook was created. ⏰
description — A human readable description of the runbook. Introduced in API microversion 1.112.
extra — A set of one or more arbitrary metadata key and value pairs.
links — A list of relative links. Includes the self and bookmark links.
steps — A set of physical information of the runbook.
public — Indicates whether the runbook is publicly accessible. 👀
owner — The name or ID of the project that owns the runbook.
traits — The traits of the runbook. A node may only be acted upon by a runbook whose traits intersect with the traits of the node. Read-only here, use the trait methods to modify it. Introduced in API microversion 1.112.
updated_at — Timestamp at which the runbook was last updated.
id — The UUID of the resource.

🪄 `add_trait(session, trait)`

Add a trait to the runbook. ✨

Parameters:

session — The session to use for making this request.
trait — The trait to add to the runbook.

Returns: None

🧹 `remove_trait(session, trait)`

Remove a trait from the runbook.

Removing a trait the runbook does not have is a no-op on the server side. so like, nothing happens, no drama, it's fine 💅

Parameters:

session — the session you're using to make this request, bestie.
- trait — the trait you wanna yeet out of the runbook.

Returns None

set_traits(session, traits) Set traits for the runbook.

This one clears out whatever traits were already there and drops in the traits you pass to this method. Pass an empty list and it nukes all the traits — total clean slate ✨

Parameters

session — the session to use for making this request.
traits — list of traits to set on the runbook.

Returns None

`openstack.baremetal.v1.volume_connector`

The VolumeConnector Class

The VolumeConnector class inherits from Resource <#openstack.resource.Resource>. 💅

class openstack.baremetal.v1.volume_connector.VolumeConnector(_synchronized=False,
       connection=None, **attrs)

The base resource

Parameters

_synchronized — okay so this is not meant to be used directly, no cap. Go look at new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing> instead.
connection — reference to the Connection being used. Defaults to None so Resource objects can exist without an active connection (unit tests, we love you). If you're using self._connection in Resource code, protect yourself with a check for None.

resources_key = 'connectors' Plural form of the key for this resource.

base_path = '/volume/connectors' The base part of the URI for this resource.

allow_create = True Allow create operation for this resource.

allow_fetch = True Allow get operation for this resource.

allow_commit = True Allow update operation for this resource.

allow_delete = True Allow delete operation for this resource.

allow_list = True Allow list operation for this resource.

allow_patch = True Allow patch operation for this resource.

commit_method = 'PATCH' Method for committing a resource. This must be PATCH if allow_patch is True — like, that's the rule, periodt.

created_at Timestamp at which the port was created.

extra A set of one or more arbitrary metadata key and value pairs.

links A list of relative links, including the self and bookmark links.

node_id The UUID of node this port belongs to.

type The types of Volume connector.

updated_at Timestamp at which the port was last updated.

id The UUID of the port.

`openstack.baremetal.v1.volume_target`

The VolumeTarget Class

The VolumeTarget class inherits from Resource <#openstack.resource.Resource>. 🦋

class openstack.baremetal.v1.volume_target.VolumeTarget(_synchronized=False,
       connection=None, **attrs)

The base resource

Parameters

_synchronized — not intended to be used directly, fr fr. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
connection — reference to the Connection being used. Defaults to None so Resource objects can be used without an active Connection, like in unit tests. Use of self._connection in Resource code should protect itself with a check for None.

resources_key = 'targets' Plural form of the key for this resource.

base_path = '/volume/targets' The base part of the URI for this resource.

allow_create = True Allow create operation for this resource.

allow_fetch = True Allow get operation for this resource.

allow_commit = True Allow update operation for this resource.

allow_delete = True Allow delete operation for this resource.

allow_list = True Allow list operation for this resource.

allow_patch = True Allow patch operation for this resource.

commit_method = 'PATCH' Method for committing a resource. This must be PATCH if allow_patch is True.

created_at Timestamp at which the port was created.

extra A set of one or more arbitrary metadata key and value pairs.

links A list of relative links. Includes the self and bookmark links.

node_id The UUID of the Node this resource belongs to.

properties A set of physical information of the volume.

updated_at Timestamp at which the port was last updated.

id The UUID of the resource.

volume_id The identifier of the volume.

volume_type The type of Volume target.

✨ Baremetal Introspection Resources ✨

`openstack.baremetal_introspection.v1.Introspection`

The Introspection Class

The Introspection class inherits from Resource <#openstack.resource.Resource>. 🧚

class openstack.baremetal_introspection.v1.introspection.Introspection(_synchronized=False,
       connection=None, **attrs)

The base resource

Parameters

_synchronized — this is not intended to be used directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.

resources_key = 'introspection' Plural form of key for resource.

base_path = '/introspection' The base part of the URI for this resource.

allow_create = True Allow create operation for this resource.

allow_fetch = True Allow get operation for this resource.

allow_commit = False Allow update operation for this resource.

allow_delete = True Allow delete operation for this resource.

allow_list = True Allow list operation for this resource.

create_opts = CreateOpts(request_key=<Unset.UNSET: 'UNSET'>, response_key=<Unset.UNSET: 'UNSET'>, method='POST', requires_id=True, response_has_body=False)

CreateOpts(request_key=<Unset.UNSET: 'UNSET'>, response_key=<Unset.UNSET: 'UNSET'>, method='POST', requires_id=True, response_has_body=False)

Class-level configuration for the create operation. Subclasses can override this to set per-resource defaults without overriding create() — iconic behavior honestly.

finished_at Timestamp at which the introspection was finished.

error The last error message (if any). 😭

id The UUID of the introspection (matches the node UUID).

is_finished Whether introspection is finished.

links A list of relative links, including the self and bookmark links.

started_at Timestamp at which the introspection was started.

state The current introspection state.

abort(session) Abort introspection.

Parameters session — the session to use for making this request.

get_data(session, processed=True) Get introspection data.

Heads up bestie: the introspection data format is not stable and can vary from environment to environment. Do not be surprised, okay?

Parameters

session — the session to use for making this request.
processed — whether to fetch the final processed data (the default) or the raw unprocessed data as received from the ramdisk.

Returns introspection data from the most recent successful run.

wait(session, timeout=None, ignore_error=False) Wait for the node to reach the expected state. 🕰️

Parameters

session — the session to use for making this request.
timeout — how much (in seconds) to wait for the introspection. The value of None (the default) means no client-side timeout.
ignore_error — if True, this call will raise an exception if the introspection reaches the error state. Otherwise the error state is considered successful and the call returns.

Returns This Introspection instance.

Raises ResourceFailure <#openstack.exceptions.ResourceFailure> if introspection fails and ignore_error is False.

Raises ResourceTimeout <#openstack.exceptions.ResourceTimeout> on timeout.

`openstack.baremetal_introspection.v1.introspection_rule`

The IntrospectionRule Class

The IntrospectionRule class inherits from Resource <#openstack.resource.Resource>. 🌸

class openstack.baremetal_introspection.v1.introspection_rule.IntrospectionRule(_synchronized=False,
       connection=None, **attrs)

The base resource

Parameters

_synchronized — not intended to be used directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.

resources_key = 'rules' Plural form of key for resource.

base_path = '/rules' The base part of the URI for this resource.

allow_create = True — creating this resource? allowed, bestie ✅
allow_fetch = True — fetching/getting this resource? also allowed, no cap.
allow_commit = False — updating this resource? nope, not here 💅
allow_delete = True — deleting it? yep, allowed.
allow_list = True — listing it? allowed, periodt.
create_opts — class-level config for the create op. The default is literally:

create_opts = CreateOpts(request_key=<Unset.UNSET: 'UNSET'>, response_key=<Unset.UNSET: 'UNSET'>, method='POST', requires_id=True, response_has_body=True)

Subclasses can override this to set per-resource defaults without overriding create(). iykyk 💅

id — the UUID of the resource.
conditions — “List of a logic statementd or operations in rules” — yes, that’s the wording, bestie 🫶
actions — list of operations that will be performed if conditions of this rule are fulfilled.
description — rule human-readable description.
scope — scope of an introspection rule.
links — a list of relative links, including the self and bookmark links.

🧱 Block Storage Resources 🧱

💾 Block Storage v2 Resources 💾

🗄️ `openstack.block_storage.v2.backup` 🗄️

The Backup Class — The Backup class inherits from Resource <#openstack.resource.Resource>. It’s giving backup main character energy.

class openstack.block_storage.v2.backup.Backup(_synchronized=False,
connection=None, **attrs)

Volume Backup. The base resource.

Parameters

_synchronized — this is not intended to be used directly. See new() (#openstack.resource.Resource.new) and existing() (#openstack.resource.Resource.existing).
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.
resource_key = 'backup' — singular form of key for resource.
resources_key = 'backups' — plural form of key for resource.
base_path = '/backups' — the base part of the URI for this resource.
allow_fetch = True — allow get operation for this resource.
allow_create = True — allow create operation for this resource.
allow_delete = True — allow delete operation for this resource.
allow_list = True — allow list operation for this resource.
availability_zone — Properties backup availability zone.
container — the container backup in.
created_at — the date and time when the resource was created.
data_timestamp — data timestamp The time when the data on the volume was first saved. If it is a backup from volume, it will be the same as created_at for a backup. If it is a backup from a snapshot, it will be the same as created_at for the snapshot.
description — backup description.
fail_reason — Backup fail reason.
force — Force backup.
has_dependent_backups — If this value is true, there are other backups depending on this backup.
is_incremental — Indicates whether the backup mode is incremental. If this value is true, the backup mode is incremental. If this value is false, the backup mode is full.
links — a list of links associated with this volume. Type: list.
name — backup name.
object_count — backup object count.
size — the size of the volume, in gibibytes (GiB).
snapshot_id — the UUID of the source volume snapshot.
status — backup status values: creating, available, deleting, error, restoring, error_restoring.
updated_at — the date and time when the resource was updated.
volume_id — the UUID of the volume.
volume_name — the name of the volume.

classmethod import_record(session, *, service, url) — Import information about a backup.

Parameters

session — the session to use for making this request.
service — the service used to perform the backup.
url — an identifier string to locate the backup.

Returns: The imported backup.

export_record(session) — Export the current backup.

Parameters

session — openstack session.

Returns: The backup export record fields.

restore(session, volume_id=None, name=None) — Restore current backup to volume.

Parameters

session — openstack session.
volume_id — the ID of the volume to restore the backup to.
name — the name for new volume creation to restore.

Returns: Updated backup instance.

force_delete(session) — Force backup deletion.

Parameters

session — the session to use for making this request.

Returns: None.

reset_status(session, status) — Reset the status of the backup.

Parameters

session — the session to use for making this request.

Returns: None.

🎛️ `openstack.block_storage.v2.capabilities` 🎛️

The Capabilities Class — The Capabilities class inherits from Resource <#openstack.resource.Resource>. Capabilities core, honestly.

class
openstack.block_storage.v2.capabilities.Capabilities(_synchronized=False,
connection=None, **attrs)

The base resource.

Parameters

_synchronized — this is not intended to be used directly. See new() (#openstack.resource.Resource.new) and existing() (#openstack.resource.Resource.existing).
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.
base_path = '/capabilities' — the base part of the URI for this resource.
allow_fetch = True — allow get operation for this resource.
description — Properties The capabilities description.
display_name — the name of volume backend capabilities.
driver_version — the driver version.
namespace — the storage namespace, such as OS::Storage::Capabilities::foo.
pool_name — the name of the storage pool.
properties — the backend volume capabilites list, which consists of cinder standard capabilities and vendor unique properties.
replication_targets — a list of volume backends used to replicate volumes on this backend.
storage_protocol — the storage backend for the backend volume.
vendor_name — the name of the vendor.
visibility — the volume type access.
volume_backend_name — the name of the back-end volume.

🧩 `openstack.block_storage.v2.consistency_group` 🧩

The ConsistencyGroup Class — The ConsistencyGroup class inherits from Resource <#openstack.resource.Resource>. Group chat, but make it storage.

class
openstack.block_storage.v2.consistency_group.ConsistencyGroup(_synchronized=False,
connection=None, **attrs)

The base resource.

Parameters

_synchronized — this is not intended to be used directly. See new() (#openstack.resource.Resource.new) and existing() (#openstack.resource.Resource.existing).
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.
resource_key = 'consistencygroup' — singular form of key for resource.
resources_key = 'consistencygroups' — plural form of key for resource.
base_path = '/consistencygroups' — the base part of the URI for this resource.
allow_fetch = True — allow get operation for this resource.
allow_create = True — allow create operation for this resource.
allow_delete = True — allow delete operation for this resource.
allow_commit = True — allow update operation for this resource.
allow_list = True — allow list operation for this resource.
availability_zone — the availability zone.
created_at — the date and time when this resource was created.
description — the description.
name — the name.
status — the status.
volume_types — the volume types.
add_volumes — comma-separated list of volume UUIDs to add to the consistency group. Used in update requests only.
remove_volumes — comma-separated list of volume UUIDs to remove from the consistency group. Used in update requests only.

classmethod create_from_source(session, *, consistency_group_snapshot_id=None, consistency_group_id=None, name=None, description=None) — Creates a new group from source.

Parameters

session — the session you're using to make this request 🫶
consistency_group_snapshot_id — the ID of a consistency group snapshot you want to build the new consistency group from. You gotta give this or consistency_group_id, like, one of them, bestie, not neither 💅
consistency_group_id — the ID of a consistency group to create the new consistency group from. Again: this or consistency_group_snapshot_id must be provided ✨
name — the name you're slapping on the new consistency group 🎀
description — the description to set on the new consistency group 🌸

Returns The created consistency group. Iconic, honestly 😌

delete(session, error_message=None, *, microversion=None, base_path=None, params=None) Deletes the remote resource that this instance is pointing at. Bye bye 👋💀

Parameters

session — the session to use when making this request.
microversion — the API version that overrides the one that got negotiated 🔥
base_path — the base part of the URI for modifying resources, if it's different from base_path <#openstack.resource.Resource.base_path>.
params — query string parameters you want included in the request URL.

Returns This Resource instance 🫶

Raises MethodNotSupported <#openstack.exceptions.MethodNotSupported> if Resource.allow_commit is not set to True.

Raises NotFoundException <#openstack.exceptions.NotFoundException> if the resource was not found 😭

🌈 `openstack.block_storage.v2.consistency_group_snapshot`

The ConsistencyGroupSnapshot Class

The ConsistencyGroupSnapshot class inherits from Resource <#openstack.resource.Resource>. Slay, lineage 💖

class openstack.block_storage.v2.consistency_group_snapshot.ConsistencyGroupSnapshot(_synchronized=False, connection=None, **attrs)

The base resource ✨

Parameters

_synchronized — this one is not meant to be used directly, okay? See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing> instead 🫶
connection — a reference to the Connection being used. It defaults to None so Resource objects can be used without an active Connection, like in unit tests. And if you're touching self._connection inside Resource code, protect yourself with a check for None, mkay? 💅

resource_key = 'cgsnapshot' The singular form of the key for this resource.

resources_key = 'cgsnapshots' The plural form of the key for this resource.

base_path = '/cgsnapshots' The base part of the URI for this resource.

allow_fetch = True Allows the get operation for this resource.

allow_create = True Allows the create operation for this resource.

allow_delete = True Allows the delete operation for this resource.

allow_list = True Allows the list operation for this resource.

consistencygroup_id The UUID of the source consistency group 🌸

created_at The date and time when this resource was created ⏰

description The description.

name The name.

status The status.

🦋 `openstack.block_storage.v2.extension`

The Extension Class

The Extension class inherits from Resource <#openstack.resource.Resource>.

class openstack.block_storage.v2.extension.Extension(_synchronized=False, connection=None, **attrs)

The base resource ✨

Parameters

_synchronized — nope, not for direct use, bestie. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing> 💅
connection — reference to the Connection being used. Defaults to None so Resource objects work without an active Connection, like in unit tests. Use of self._connection in Resource code should protect itself with a check for None 🫶

resources_key = 'extensions' The plural form of the key for this resource.

base_path = '/extensions' The base part of the URI for this resource.

allow_list = True Allows the list operation for this resource.

alias The alias for the extension.

description The extension description.

links Links pertaining to this extension 🔗

name The name of this extension.

namespace A URL pointing to the namespace for this extension.

updated_at The date and time when the resource was updated. The date and time stamp format is ISO 8601 ⏰✨

🎀 `openstack.block_storage.v2.limits`

The AbsoluteLimit Class

The AbsoluteLimit class inherits from Resource <#openstack.resource.Resource>.

class openstack.block_storage.v2.limits.AbsoluteLimit(_synchronized=False, connection=None, **attrs)

The base resource ✨

Parameters

_synchronized — not intended to be used directly, periodt. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing> 💅
connection — reference to the Connection being used. Defaults to None so Resource objects can be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None 🫶

max_total_backup_gigabytes The maximum total amount of backups, in gibibytes (GiB).

max_total_backups The maximum number of backups.

max_total_snapshots The maximum number of snapshots.

max_total_volume_gigabytes The maximum total amount of volumes, in gibibytes (GiB).

max_total_volumes The maximum number of volumes.

total_backup_gigabytes_used The total number of backups gibibytes (GiB) used.

total_backups_used The total number of backups used.

total_gigabytes_used The total number of gibibytes (GiB) used.

total_snapshots_used The total number of snapshots used.

total_volumes_used The total number of volumes used 📊

The Limits Class

The Limit class inherits from Resource <#openstack.resource.Resource>.

class openstack.block_storage.v2.limits.Limits(_synchronized=False, connection=None, **attrs)

The base resource ✨

Parameters

_synchronized — this is not intended to be used directly, okay? See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing> 💅
connection — reference to the Connection being used. Defaults to None so Resource objects can be used without an active Connection, like in unit tests. Use of self._connection in Resource code should protect itself with a check for None 🫶

resource_key = 'limits' The singular form of the key for this resource.

base_path = '/limits' The base part of the URI for this resource.

allow_fetch = True Allows the get operation for this resource.

absolute An absolute limits object.

rate Rate-limit volume copy bandwidth, used to mitigate slowdown of data access from the instances 🏎️💨

The RateLimit Class

The RateLimit class inherits from Resource <#openstack.resource.Resource>.

class openstack.block_storage.v2.limits.RateLimit(_synchronized=False, connection=None, **attrs)

The base resource ✨

Parameters

_synchronized — do not use this directly, bestie. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing> 💅
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None 🫶

next_available Rate limits next available time ⏳

remaining Integer for rate limits remaining.

unit Unit of measurement for the value parameter.

value Integer number of requests which can be made.

verb An HTTP verb (POST, PUT, etc.) 🔥

The RateLimits Class

The RateLimits class inherits from Resource <#openstack.resource.Resource>.

class openstack.block_storage.v2.limits.RateLimits(_synchronized=False, connection=None, **attrs)

The base resource ✨

Parameters

_synchronized — not meant to be used directly, periodt. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing> 💅
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None 🫶

limits A list of the specific limits that apply to the regex and uri.

regex A regex representing which routes this rate limit applies to.

uri A URI representing which routes this rate limit applies to 🌈

🧚 `openstack.block_storage.v2.qos_spec`

The QoSSpec Class

The QoSSpec class inherits from Resource <#openstack.resource.Resource>.

associate(session, vol_type_id) — links this QoS spec to a volume type, bestie. Params: session (the session for making this request) and vol_type_id (the ID of the volume type you're associating with). 💅
disassociate(session, vol_type_id) — breaks up this QoS spec and a volume type 😭 params again: session (session for the request) and vol_type_id (the ID of the volume type you're disassociating from).
disassociate_all(session) — severs this QoS spec from all the volume types at once, no cap. Param: session — the session to use for making this request.
delete_keys(session, keys) — yeets keys out of this QoS spec. Params: session (session for the request) and keys (the keys to delete). 🗑️

openstack.block_storage.v2.qos_spec — the QoSSpecAssociation era 🦋

The QoSSpecAssociation Class

The QoSSpecAssociation class inherits from Resource.

class openstack.block_storage.v2.qos_spec.QoSSpecAssociation(_synchronized=False,
connection=None, **attrs)

It's the base resource, periodt. Parameters:

_synchronized — literally not meant to be used directly, iykyk. See new() and existing().
connection — reference to the Connection being used. Defaults to None so Resource objects can exist without an active Connection, like in unit tests. Any use of self._connection in Resource code should protect itself with a check for None. 🫶

resources_key = 'qos_associations' — plural form of key for resource.

base_path = '/qos-specs/%(qos_spec_id)s/associations' — the base part of the URI for this resource.

allow_list = True — list operation is allowed for this resource.

association_type — the type of association (e.g. "volume_type"). ⭐

id — the ID of the associated resource.

name — the name of the associated resource.

qos_spec_id — the ID of the QoS spec. 💖

openstack.block_storage.v2.quota_class_set ✨

The QuotaClassSet Class

The QuotaClassSet class inherits from Resource.

class openstack.block_storage.v2.quota_class_set.QuotaClassSet(_synchronized=False,
connection=None, **attrs)

Base resource energy. Parameters:

_synchronized — please do not use this directly, it's not for you. See new() and existing().
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None. 💀

resource_key = 'quota_class_set' — singular form of key for resource.

base_path = '/os-quota-class-sets' — the base part of the URI for this resource.

allow_fetch = True — get operation is allowed for this resource.

allow_commit = True — update operation is allowed for this resource.

backup_gigabytes — the size (GiB) of backups that are allowed for each project.

backups — the number of backups that are allowed for each project.

gigabytes — the size (GiB) of volumes and snapshots that are allowed for each project.

groups — the number of groups that are allowed for each project.

per_volume_gigabytes — the size (GiB) of volumes in request that are allowed for each volume.

snapshots — the number of snapshots that are allowed for each project.

volumes — the number of volumes that are allowed for each project. 🎀

openstack.block_storage.v2.quota_set 🌸

The QuotaSet Class

The QuotaSet class inherits from Resource.

class openstack.block_storage.v2.quota_set.QuotaSet(_synchronized=False,
connection=None, **attrs)

The base resource, as ever. Parameters:

_synchronized — not intended to be used directly. See new() and existing().
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None. 🧚

backup_gigabytes — properties, the size (GB) of backups that are allowed for each project. (Yep, GB here, not GiB — that's what it says, don't come for me 🙈)

backups — the number of backups that are allowed for each project.

gigabytes — the size (GB) of volumes and snapshots that are allowed for each project.

groups — the number of groups that are allowed for each project.

per_volume_gigabytes — the size (GB) of volumes in request that are allowed for each volume.

snapshots — the number of snapshots that are allowed for each project.

volumes — the number of volumes that are allowed for each project. 💜

openstack.block_storage.v2.service 🔥

The Service Class

The Service class inherits from Resource.

class openstack.block_storage.v2.service.Service(_synchronized=False,
connection=None, **attrs)

Base resource behaviour, iconic as always. Parameters:

_synchronized — not intended to be used directly. See new() and existing().
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None. 🌈

resources_key = 'services' — plural form of key for resource.

base_path = '/os-services' — the base part of the URI for this resource.

allow_list = True — list operation is allowed for this resource.

active_backend_id — the ID of active storage backend (cinder-volume services only).

availability_zone — the availability zone of service.

binary — binary name of service.

disabled_reason — disabled reason of service.

host — the name of the host where service runs.

name — service name.

replication_status — the volume service replication status (cinder-volume services only).

state — state of service.

status — status of service.

updated_at — the date and time when the resource was updated. ⏰

classmethod find(session, name_or_id, ignore_missing=True, list_base_path=None, *, microversion=None, all_projects=None, **params)

Find a resource by its name or id. The signature is exactly that, all_projects included — that's the vibe check, no further tea in the docs. 🍓

Parameters:

session — the session to use for making this request.
name_or_id — this resource's identifier, if needed by the request. The default is None.
ignore_missing — when set to False, NotFoundException (from openstack.exceptions) will be raised when the resource does not exist. When set to True, None will be returned when attempting to find a nonexistent resource. 👑
list_base_path — base_path to be used when need listing resources.
microversion — API version to override the negotiated one.
params — any additional parameters to be passed into underlying methods, such as to existing() in order to pass on URI parameters.

Ngl, that ignore_missing default of True is lowkey the whole personality of this method — False means it will throw hands via NotFoundException. 💅

Returns — the Resource object that matches the name or id you handed it, or None if literally nothing matches. 🫶

Raises openstack.exceptions.DuplicateResource if more than one resource shows up for this request (messy, we don't love that).

Raises openstack.exceptions.NotFoundException if nothing is found and ignore_missing is False. no vibes found, so it throws hands 😭

`commit(session, prepend_key=False, *args, **kwargs)`

Commits the state of your instance to the remote resource. like hitting send on the whole object 💅

Parameters

session — the session used to make this request.
prepend_key — whether resource_key should be prepended in a resource creation request. Default to True. (yes, the signature says False, the docs say True, that's just how it is, don't come for me 🙈)
retry_on_conflict — whether to enable retries on HTTP CONFLICT (409). A value of None leaves the Adapter defaults alone.
base_path — base part of the URI for modifying resources, if it's different from base_path.
microversion — API version to override the negotiated one.
attrs — attributes to pass when updating the resource. These should correspond to either Body or Header values on the resource.

Returns — this Resource instance. iconic.

Raises MethodNotSupported if Resource.allow_commit is not set to True. so check your flags bestie ✨

`enable(session)`

Enable service. that's it, that's the whole thing 💖

`disable(session, *, reason=None)`

Disable service. you can pass a reason, optional, no pressure.

`failover(session, *, backend_id=None)`

Failover a service.

Only applies to replicating cinder-volume services. like, specifically those, don't try it elsewhere 🔥

🦋 `openstack.block_storage.v2.snapshot`

The Snapshot Class

The Snapshot class inherits from Resource.

class openstack.block_storage.v2.snapshot.Snapshot(_synchronized=False,
connection=None, **attrs)

The base resource.

Parameters

_synchronized — this is not intended to be used directly. See new() and existing().
connection — reference to the Connection being used. Defaults to None so Resource objects can be used without an active Connection, like in unit tests. Use of self._connection in Resource code should protect itself with a check for None. safety first 🎀

resource_key = 'snapshot' : Singular form of key for resource.

resources_key = 'snapshots' : Plural form of key for resource.

base_path = '/snapshots' : The base part of the URI for this resource.

allow_fetch = True : Allow get operation for this resource.

allow_create = True : Allow create operation for this resource.

allow_delete = True : Allow delete operation for this resource.

allow_commit = True : Allow update operation for this resource.

allow_list = True : Allow list operation for this resource.

created_at : The timestamp of this snapshot creation.

description : Description of snapshot. Default is None.

is_forced : Indicate whether to create snapshot, even if the volume is attached. Default is False. Type: bool.

size : The size of the volume, in gibibytes (GiB).

status : The current status of this snapshot. Potential values are creating, available, deleting, error, and error_deleting.

updated_at : The date and time when the resource was updated.

volume_id : The ID of the volume this snapshot was taken of.

`force_delete(session)`

Force snapshot deletion. blunt force, but make it storage 💀

`reset_status(session, status)`

Reset the status of the snapshot. you say what the status should be, it obeys.

`classmethod manage(session, volume_id, ref, name=None, description=None, metadata=None)`

Manage a snapshot under block storage provisioning.

`unmanage(session)`

Unmanage a snapshot from block storage provisioning. bestie broke up with the snapshot 🥀

The SnapshotDetail Class

The SnapshotDetail class inherits from Snapshot.

openstack.block_storage.v2.snapshot.SnapshotDetail : alias of Snapshot.

🌸 `openstack.block_storage.v2.stats`

The Pools Class

The Pools class inherits from Resource.

class openstack.block_storage.v2.stats.Pools(_synchronized=False,
connection=None, **attrs)

The base resource.

Parameters

_synchronized — this is not intended to be used directly. See new() and existing().
connection — reference to the Connection being used. Defaults to None so Resource objects can be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.

resource_key = '' : Singular form of key for resource. (yes, it's an empty string, that's not a typo 🫠)

resources_key = 'pools' : Plural form of key for resource.

base_path = '/scheduler-stats/get_pools?detail=True' : The base part of the URI for this resource.

allow_fetch = False : Allow get operation for this resource.

allow_create = False : Allow create operation for this resource.

allow_delete = False : Allow delete operation for this resource.

allow_list = True : Allow list operation for this resource.

name : The Cinder name for the pool.

capabilities : returns a dict with information about the pool.

💜 `openstack.block_storage.v2.transfer`

The Volume Transfer Class

The Volume Transfer class inherits from Resource.

class openstack.block_storage.v2.transfer.Transfer(_synchronized=False,
connection=None, **attrs)

The base resource.

Parameters

_synchronized — this is not intended to be used directly. See new() and existing().
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.

resource_key = 'transfer' : Singular form of key for resource.

resources_key = 'transfers' : Plural form of key for resource.

base_path = '/os-volume-transfer' : The base part of the URI for this resource.

allow_create = True : Allow create operation for this resource.

allow_delete = True : Allow delete operation for this resource.

allow_fetch = True : Allow get operation for this resource.

allow_list = True : Allow list operation for this resource.

id : UUID of the transfer.

created_at : The date and time when the resource was created.

name : Name of the volume to transfer.

volume_id : ID of the volume to transfer.

auth_key : Auth key for the transfer. 🔑

links : A list of links associated with this volume. Type: list.

`accept(session, *, auth_key=None)`

Accept a volume transfer. say yes to the transfer 💌

Parameters

session — the session to use for making this request.
auth_key — the authentication key for the volume transfer.

Returns — this Transfer instance.

⭐ `openstack.block_storage.v2.type`

The Type Class

The Type class inherits from Resource.

class openstack.block_storage.v2.type.Type(_synchronized=False,
connection=None, **attrs)

The base resource.

Parameters

_synchronized — this is not intended to be used directly. See new() and existing().
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.

resource_key = 'volume_type' : Singular form of key for resource.

resources_key = 'volume_types' : Plural form of key for resource.

base_path = '/types' : The base part of the URI for this resource.

allow_fetch = True : Allow get operation for this resource.

allow_create = True : Allow create operation for this resource.

allow_delete = True : Allow delete operation for this resource.

allow_list = True : Allow list operation for this resource.

extra_specs : A dict of extra specifications. "capabilities" is a usual key.

is_public : a private volume-type. Type: bool. (that's what it says, and yes the wording is a little cursed, but we move 😭)

`set_extra_specs(session, **extra_specs)`

Update extra specs.

This call will replace only the extra_specs with the same keys given here. Other keys will not be modified. so it's surgical, not a nuke 💅

Parameters

(the deets roll in right here — keep it moving, bestie 🧚)

session — the session you're using to make this request 🫶
extra_specs — key/value extra_specs pairs to be update on this volume type. All keys and values.

Returns — the updated extra specs. ✨

🎀 `delete_extra_specs(session, keys)`

Delete extra specs. Bye girl 💅

⚠️ okay so real talk: this method will do a HTTP DELETE request for every key in keys. Not one big batch. Every. Single. Key. Just so you know what you're signing up for 🫠

Parameters

session — the session to use for this request.
keys — the keys to delete.

Returns — None

🦋 `get_private_access(session)`

List projects with private access to the volume type. Peek at the guest list 👀

Parameters

session — the session to use for making this request.

Returns — the volume type access response.

🌸 `add_private_access(session, project_id)`

Add project access from the volume type.

Parameters

session — the session to use for making this request.
project_id — the project to add access for.

🌼 `remove_private_access(session, project_id)`

Remove project access from the volume type. Sorry bestie, you're off the list 😭

Parameters

session — the session to use for making this request.
project_id — the project to remove access for.

🧊 `openstack.block_storage.v2.volume`

👑 The Volume Class

The Volume class inherits from Resource <#openstack.resource.Resource>.

class openstack.block_storage.v2.volume.Volume(_synchronized=False,
connection=None, **attrs)

The base resource.

Parameters

_synchronized — this is not intended to be used directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.

resource_key = 'volume' — singular form of key for resource.

resources_key = 'volumes' — plural form of key for resource.

base_path = '/volumes' — the base part of the URI for this resource.

allow_fetch = True — allow get operation for this resource.

allow_create = True — allow create operation for this resource.

allow_delete = True — allow delete operation for this resource.

allow_commit = True — allow update operation for this resource.

allow_list = True — allow list operation for this resource.

attachments — TODO(briancurtin): This is currently undocumented in the API.

availability_zone — the availability zone.

consistency_group_id — ID of the consistency group.

created_at — the timestamp of this volume creation.

description — the volume description.

extended_replication_status — extended replication status on this volume.

host — the volume's current back-end.

image_id — the ID of the image from which you want to create the volume. Required to create a bootable volume.

is_bootable — enables or disables the bootable attribute. You can boot an instance from a bootable volume. Type: bool

is_encrypted — True if this volume is encrypted, False if not. Type: bool

is_multiattach — whether volume will be sharable or not.

migration_id — the volume ID that this volume's name on the back-end is based on.

migration_status — the status of this volume's migration (None means that a migration is not currently in progress).

project_id — the project ID associated with current back-end.

replication_driver_data — data set by the replication driver

replication_status — status of replication on this volume.

scheduler_hints — scheduler hints for the volume

size — the size of the volume, in gibibytes (GiB). Type: int

snapshot_id — to create a volume from an existing snapshot, specify the ID of the existing volume snapshot. If specified, the volume is created in same availability zone and with same size of the snapshot.

source_volume_id — to create a volume from an existing volume, specify the ID of the existing volume. If specified, the volume is created with same size of the source volume.

status — one of the following values: creating, available, attaching, in-use deleting, error, error_deleting, backing-up, restoring-backup, error_restoring. For details on these statuses, see the Block Storage API documentation.

updated_at — the date and time when the resource was updated.

user_id — the user ID associated with the volume

volume_image_metadata — one or more metadata key and value pairs about image

volume_type — the name of the associated volume type.

⭐ `extend(session, size)`

Extend a volume size. Make it bigger, make it iconic 💖

⭐ `set_bootable_status(session, bootable=True)`

Set volume bootable status flag.

⭐ `set_readonly(session, readonly)`

Set volume readonly flag.

⭐ `set_image_metadata(session, metadata)`

Sets image metadata key-value pairs on the volume.

⭐ `delete_image_metadata(session)`

Remove all image metadata from the volume. Clean slate energy ✨

⭐ `delete_image_metadata_item(session, key)`

Remove a single image metadata from the volume.

⭐ `reset_status(session, status=None, attach_status=None, migration_status=None)`

Reset volume statuses (admin operation). Admin only, bestie — main character privileges 👑

⭐ `attach(session, mountpoint, instance=None, host_name=None)`

Attach volume to server.

⭐ `detach(session, attachment, force=False, connector=None)`

Detach volume from server.

⭐ `unmanage(session)`

Unmanage volume.

⭐ `retype(session, new_type, migration_policy=None)`

Change volume type. Glow-up arc 🌈

⭐ `migrate(session, host=None, force_host_copy=False, lock_volume=False)`

Migrate volume.

⭐ `complete_migration(session, new_volume_id, error=False)`

Complete volume migration.

⭐ `force_delete(session)`

Force volume deletion.

⭐ `upload_to_image(session, image_name, *, force=False, disk_format=None, container_format=None)`

Upload the volume to image service.

🧚 Block Storage v3 Resources

🦋 `openstack.block_storage.v3.attachment`

💜 The Volume Attachment Class

The Volume Attachment class inherits from Resource <#openstack.resource.Resource>.

class openstack.block_storage.v3.attachment.Attachment(_synchronized=False,
connection=None, **attrs)

The base resource

Parameters

_synchronized — this is not intended to be used directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.

🎀 `complete(session, *, microversion=None)`

Mark the attachment as completed. Finished, done, periodt 💅

🌟 `create(session, prepend_key=True, base_path=None, *, resource_request_key=None, resource_response_key=None, microversion=None, **params)`

Create a remote resource based on this instance.

Parameters

session — the session to use for making this request.
prepend_key — DEPRECATED — configure create_opts instead. Whether the resource_key should be prepended in a resource creation request. Default to True.
base_path — base part of the URI for creating resources, if different from base_path <#openstack.resource.Resource.base_path>.
resource_request_key — DEPRECATED — configure create_opts instead. Overrides the usage of resource_key <#openstack.resource.Resource.resource_key> when prepending a key to the request body. Ignored if prepend_key is false.
resource_response_key — DEPRECATED — configure create_opts instead. Overrides the usage of resource_key <#openstack.resource.Resource.resource_key> when processing response bodies. Ignored if prepend_key is false.
microversion — API version to override the negotiated one.
params — additional params to pass.

Returns — this Resource instance.

Raises — MethodNotSupported <#openstack.exceptions.MethodNotSupported> if Resource.allow_create is not set to True. 😭 no creating for you if that flag's off, fr fr.

update([E], **F) -> None. — Update D from mapping/iterable E and F. If E is present and has a .keys() method, then does: for k in E.keys(): D[k] = E[k] If E is present and lacks a .keys() method, then does: for k, v in E: D[k] = v In either case, this is followed by: for k in F: D[k] = F[k]

🧊 `openstack.block_storage.v3.availability_zone`

The AvailabilityZone Class 💫

okay so the AvailabilityZone class inherits from Resource <#openstack.resource.Resource> — yes bestie, it's giving inheritance hierarchy realness 🫶

class openstack.block_storage.v3.availability_zone.AvailabilityZone(_synchronized=False,
connection=None, **attrs)

The base resource, periodt.

Parameters

_synchronized — This is not intended to be used directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>. 🙈 like pls don't touch, it's not for you
connection — Reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None. 💅

resource_key = '' — Singular form of key for resource. ✨

resources_key = 'availabilityZoneInfo' — Plural form of key for resource. 🌸

base_path = '/os-availability-zone' — The base part of the URI for this resource. 🔥

allow_list = True — Allow list operation for this resource. 👑

Properties 🦋

name — Name of availability zone
state — State of availability zone, "available" is usual key

💾 `openstack.block_storage.v3.backup`

The Backup Class 🎀

The Backup class inherits from Resource <#openstack.resource.Resource>.

class openstack.block_storage.v3.backup.Backup(_synchronized=False,
connection=None, **attrs)

Volume Backup — iconic, lowkey essential 😭

The base resource

Parameters

_synchronized — This is not intended to be used directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>. 🫶
connection — Reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None. 💜

resource_key = 'backup' — Singular form of key for resource. ⭐

resources_key = 'backups' — Plural form of key for resource. 🌈

base_path = '/backups' — The base part of the URI for this resource. ✨

allow_fetch = True — Allow get operation for this resource. 💖

allow_create = True — Allow create operation for this resource. 🧚

allow_delete = True — Allow delete operation for this resource. 💀

allow_commit = True — Allow update operation for this resource. 🔥

allow_list = True — Allow list operation for this resource. 👑

Properties 🍓

availability_zone — backup availability zone
container — The container backup in
created_at — The date and time when the resource was created.
data_timestamp — data timestamp The time when the data on the volume was first saved. If it is a backup from volume, it will be the same as created_at for a backup. If it is a backup from a snapshot, it will be the same as created_at for the snapshot.
description — backup description
encryption_key_id — The UUID of the encryption key. Only included for encrypted volumes.
fail_reason — Backup fail reason
force — Force backup
has_dependent_backups — If this value is true, there are other backups depending on this backup.
is_incremental — Indicates whether the backup mode is incremental. If this value is true, the backup mode is incremental. If this value is false, the backup mode is full.
links — A list of links associated with this volume. Type: list
metadata — The backup metadata. New in version 3.43
name — backup name
object_count — backup object count
project_id — The UUID of the owning project. New in version 3.18
size — The size of the volume, in gibibytes (GiB).
snapshot_id — The UUID of the source volume snapshot.
status — backup status values: creating, available, deleting, error, restoring, error_restoring
updated_at — The date and time when the resource was updated.
user_id — The UUID of the project owner. New in 3.56
volume_id — The UUID of the volume.
volume_name — The name of the volume.

classmethod import_record(session, *, service, url) — Import information about a backup 🌸

Parameters

session — The session to use for making this request.
service — The service used to perform the backup.
url — An identifier string to locate the backup.

Returns — The imported backup

export_record(session) — Export information about the backup ✨

Parameters

session — The session to use for making this request.

Returns — The backup export record fields

export(session) — Export information about the backup 🦋

Parameters

session — The session to use for making this request.

Returns — The backup export record fields

restore(session, volume_id=None, name=None) — Restore current backup to volume 💖

Parameters

session — The session to use for making this request.
volume_id — The ID of the volume to restore the backup to.
name — The name for new volume creation to restore.

Returns — Updated backup instance

force_delete(session) — Force backup deletion 💀

Parameters

session — The session to use for making this request.

Returns — None

reset_status(session, status) — Reset the status of the backup 🔄

Parameters

session — The session to use for making this request.

Returns — None

📊 `openstack.block_storage.v3.block_storage_summary`

The Block Storage Summary Class 👑

The Block Storage Summary class inherits from Resource <#openstack.resource.Resource>.

class openstack.block_storage.v3.block_storage_summary.BlockStorageSummary(_synchronized=False,
connection=None, **attrs)

The base resource

Parameters

_synchronized — This is not intended to be used directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>. 🙈
connection — Reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None. 💅

base_path = '/volumes/summary' — The base part of the URI for this resource. ✨

allow_fetch = True — Allow get operation for this resource. 🌟

Properties 🎀

total_size — Total size of all the volumes
total_count — Total count of all the volumes
metadata — Metadata of all the volumes

🛠️ `openstack.block_storage.v3.capabilities`

The Capabilities Class 🧚

The Capabilities class inherits from Resource <#openstack.resource.Resource>.

class openstack.block_storage.v3.capabilities.Capabilities(_synchronized=False,
connection=None, **attrs)

The base resource

Parameters

_synchronized — This is not intended to be used directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>. 🫶
connection — Reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None. 💜

base_path = '/capabilities' — The base part of the URI for this resource. 🔥

allow_fetch = True — Allow get operation for this resource. 🌈

Properties 🍓

description — The capabilities description
display_name — The name of volume backend capabilities.
driver_version — The driver version.
namespace — The storage namespace, such as OS::Storage::Capabilities::foo.
pool_name — The name of the storage pool.
properties — The backend volume capabilites list, which consists of cinder standard capabilities and vendor unique properties.
replication_targets — A list of volume backends used to replicate volumes on this backend.
storage_protocol — The storage backend for the backend volume.
vendor_name — The name of the vendor.
visibility — The volume type access.
volume_backend_name — The name of the back-end volume.

`openstack.block_storage.v3.cluster`

The Cluster Class — okay bestie, this one inherits from Resource (openstack.resource.Resource) and it’s giving storage-cluster realness 🫶.

class openstack.block_storage.v3.cluster.Cluster(_synchronized=False, connection=None, **attrs)

The base resource.

Parameters

_synchronized — This is not intended to be used directly. See new() (openstack.resource.Resource.new) and existing() (openstack.resource.Resource.existing).
connection — Reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.

Cluster class config + attrs ✨

resource_key = 'cluster' — Singular form of key for resource.
resources_key = 'clusters' — Plural form of key for resource.
base_path = '/clusters' — The base part of the URI for this resource.
allow_fetch = True — Allow get operation for this resource.
allow_list = True — Allow list operation for this resource.
active_backend_id — The ID of active storage backend (cinder-volume services only).
binary — The binary name of the services in the cluster.
created_at — The date and time when the resource was created.
disabled_reason — The reason for disabling the cluster.
frozen — Whether the cluster is frozen for replication.
last_heartbeat — The last periodic heartbeat received.
name — The name of the cluster.
num_down_hosts — The number of down hosts in the cluster.
num_hosts — The number of hosts in the cluster.
replication_status — The cluster replication status.
state — The state of the cluster. One of up or down.
status — The status of the cluster. One of enabled or disabled.
updated_at — The date and time when the resource was last updated.

Methods 💅

enable(session) — Enable scheduling for the cluster.
disable(session, *, reason=None) — Disable scheduling for the cluster.
- reason — The reason for disabling the cluster.

`openstack.block_storage.v3.consistency_group`

The ConsistencyGroup Class — this one also inherits from Resource (openstack.resource.Resource), and it’s consistency-group coded fr fr 🎀.

class openstack.block_storage.v3.consistency_group.ConsistencyGroup(_synchronized=False, connection=None, **attrs)

The base resource.

Parameters

_synchronized — This is not intended to be used directly. See new() (openstack.resource.Resource.new) and existing() (openstack.resource.Resource.existing).
connection — Reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.

ConsistencyGroup class config + attrs 🌸

resource_key = 'consistencygroup' — Singular form of key for resource.
resources_key = 'consistencygroups' — Plural form of key for resource.
base_path = '/consistencygroups' — The base part of the URI for this resource.
allow_fetch = True — Allow get operation for this resource.
allow_create = True — Allow create operation for this resource.
allow_delete = True — Allow delete operation for this resource.
allow_commit = True — Allow update operation for this resource.
allow_list = True — Allow list operation for this resource.
availability_zone — The availability zone.
created_at — The date and time when this resource was created.
description — The description.
name — The name.
status — The status.
volume_types — The volume types.
add_volumes — Comma-separated list of volume UUIDs to add to the consistency group. Used in update requests only.
remove_volumes — Comma-separated list of volume UUIDs to remove from the consistency group. Used in update requests only.

classmethod create_from_source(...) — Creates a new group from source. Lowkey iconic behavior ✨

classmethod create_from_source(session, *, consistency_group_snapshot_id=None, consistency_group_id=None, name=None, description=None)

Parameters

session — The session to use for making this request
consistency_group_snapshot_id — The ID of a consistency group snapshot to create the new consistency group from. Either this or consistency_group_id must be provided
consistency_group_id — The ID of a consistency group to create the new consistency group from. Either this or consistency_group_snapshot_id must be provided
name — The name to assign to the new consistency group
description — The description to set on the new consistency group

Returns — The created consistency group

delete(...) — Delete the remote resource based on this instance. Bestie, this is the cleanup arc 💀

delete(session, error_message=None, *, microversion=None, base_path=None, params=None)

Parameters

session — The session to use for making this request.
microversion — API version to override the negotiated one.
base_path — Base part of the URI for modifying resources, if different from base_path (openstack.resource.Resource.base_path).
params — Query string parameters to include in the request URL.

Returns — This Resource instance.

Raises MethodNotSupported (openstack.exceptions.MethodNotSupported) if Resource.allow_commit is not set to True.
Raises NotFoundException (openstack.exceptions.NotFoundException) if the resource was not found.

`openstack.block_storage.v3.consistency_group_snapshot`

The ConsistencyGroupSnapshot Class — inherits from Resource (openstack.resource.Resource). Snapshot era, no cap 📸

class openstack.block_storage.v3.consistency_group_snapshot.ConsistencyGroupSnapshot(_synchronized=False, connection=None, **attrs)

The base resource.

Parameters

_synchronized — This is not intended to be used directly. See new() (openstack.resource.Resource.new) and existing() (openstack.resource.Resource.existing).
connection — Reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.

ConsistencyGroupSnapshot class config + attrs 🦋

resource_key = 'cgsnapshot' — Singular form of key for resource.
resources_key = 'cgsnapshots' — Plural form of key for resource.
base_path = '/cgsnapshots' — The base part of the URI for this resource.
allow_fetch = True — Allow get operation for this resource.
allow_create = True — Allow create operation for this resource.
allow_delete = True — Allow delete operation for this resource.
allow_list = True — Allow list operation for this resource.
consistencygroup_id — The UUID of the source consistency group.
created_at — The date and time when this resource was created.
description — The description.
name — The name.
status — The status.

`openstack.block_storage.v3.default_type`

The DefaultType Class — inherits from Resource (openstack.resource.Resource). Default-type main character energy 👑

class openstack.block_storage.v3.default_type.DefaultType(_synchronized=False, connection=None, **attrs)

The base resource.

Parameters

_synchronized — This is not intended to be used directly. See new() (openstack.resource.Resource.new) and existing() (openstack.resource.Resource.existing).
connection — Reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.

DefaultType class config + attrs 🍓

resource_key = 'default_type' — Singular form of key for resource.
resources_key = 'default_types' — Plural form of key for resource.
base_path = '/default-types' — The base part of the URI for this resource.
allow_fetch = True — Allow get operation for this resource.
allow_create = True — Allow create operation for this resource.
allow_delete = True — Allow delete operation for this resource.
allow_list = True — Allow list operation for this resource.
create_opts = CreateOpts(request_key=<Unset.UNSET: 'UNSET'>, response_key=<Unset.UNSET: 'UNSET'>, method='PUT', requires_id=True, response_has_body=True) — Class-level configuration for the create operation. Subclasses can override this to set per-resource defaults without overriding create().
project_id — The UUID of the project.
volume_type_id — the UUID for an existing volume type. 💖

🦋 openstack.block_storage.v3.extension

💅 The Extension Class

The Extension class inherits from Resource <#openstack.resource.Resource>. Bestie, it's giving core resource energy.

class openstack.block_storage.v3.extension.Extension(_synchronized=False, connection=None, **attrs)

This is The base resource. No cap.

Parameters:

_synchronized — this is not intended to be used directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.
resources_key = 'extensions' — plural form of key for resource.
base_path = '/extensions' — the base part of the URI for this resource.
allow_list = True — allow list operation for this resource.

Properties:

alias — the alias for the extension.
description — the extension description.
links — links pertaining to this extension.
name — the name of this extension.
updated_at — the date and time when the resource was updated. The date and time stamp format is ISO 8601. 🕰️

🌸 openstack.block_storage.v3.group

🎀 The Group Class

The Group class inherits from Resource <#openstack.resource.Resource>. Yup, another icon inheriting from the base resource.

class openstack.block_storage.v3.group.Group(_synchronized=False, connection=None, **attrs)

This is The base resource, periodt.

Parameters:

_synchronized — this is not intended to be used directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.
resource_key = 'group' — singular form of key for resource.
resources_key = 'groups' — plural form of key for resource.
base_path = '/groups' — the base part of the URI for this resource.
allow_fetch = True — allow get operation for this resource.
allow_create = True — allow create operation for this resource.
allow_delete = True — allow delete operation for this resource.
allow_commit = True — allow update operation for this resource.
allow_list = True — allow list operation for this resource.
add_volumes — a comma-separated list of volume IDs to add to the group.
remove_volumes — a comma-separated list of volume IDs to remove from the group.
delete(session, error_message=None, *, microversion=None, delete_volumes=False, **attrs) — delete a group.
fetch_replication_targets(session) — fetch replication targets for the group. Parameters: session — the session to use for making this request. Returns: this group with the replication_targets field populated.
enable_replication(session) — enable replication for the group. Parameters: session — the session to use for making this request.
disable_replication(session) — disable replication for the group. Parameters: session — the session to use for making this request.
failover_replication(session, *, allowed_attached_volume=False, secondary_backend_id=None) — failover replication for the group. Parameters:
- session — the session to use for making this request.
- allowed_attached_volume — whether to allow attached volumes in the group.
- secondary_backend_id — the secondary backend ID. Returns: None.
reset_status(session, status) — resets the status for a group. Parameters:
- session — the session to use for making this request.
- status — the status for the group.
classmethod create_from_source(session, group_snapshot_id, source_group_id, name=None, description=None) — creates a new group from source.

💜 openstack.block_storage.v3.group_snapshot

🧚 The GroupSnapshot Class

The GroupSnapshot class inherits from Resource <#openstack.resource.Resource>. Snapshot behavior, but make it group chat.

class openstack.block_storage.v3.group_snapshot.GroupSnapshot(_synchronized=False, connection=None, **attrs)

This is The base resource. Lowkey iconic.

Parameters:

_synchronized — this is not intended to be used directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.
resource_key = 'group_snapshot' — singular form of key for resource.
resources_key = 'group_snapshots' — plural form of key for resource.
base_path = '/group_snapshots' — the base part of the URI for this resource.
allow_fetch = True — allow get operation for this resource.
allow_create = True — allow create operation for this resource.
allow_delete = True — allow delete operation for this resource.
allow_commit = False — allow update operation for this resource? Nope, it's False, so updates are not allowed.
allow_list = True — allow list operation for this resource.

Properties:

created_at — the date and time when the resource was created.
description — the group snapshot description.
group_id — the UUID of the source group.
group_type_id — the group type ID.
id — the ID of the group snapshot.
name — the group snapshot name.
project_id — the UUID of the volume group snapshot project.
status — the status of the generic group snapshot.
reset_status(session, state) — resets the status for a group snapshot. 🫶

🔥 openstack.block_storage.v3.group_type

👑 The GroupType Class

The GroupType class inherits from Resource <#openstack.resource.Resource>. Main character group type behavior, fr fr.

class openstack.block_storage.v3.group_type.GroupType(_synchronized=False, connection=None, **attrs)

This is The base resource, bestie.

Parameters:

_synchronized — this is not intended to be used directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.
resource_key = 'group_type' — singular form of key for resource.
resources_key = 'group_types' — plural form of key for resource.
base_path = '/group_types' — the base part of the URI for this resource.
allow_fetch = True — allow get operation for this resource.
allow_create = True — allow create operation for this resource.
allow_delete = True — allow delete operation for this resource.
allow_commit = True — allow update operation for this resource.
allow_list = True — allow list operation for this resource.

Properties:

description — the group type description.
group_specs — contains the specifications for a group type.
is_public — whether the group type is publicly visible.
fetch_group_specs(session) — fetch group_specs of the group type. These are returned by default if the user has suitable permissions (i.e. you're an admin) but by default you also need the same permissions to access this API. That means this function is kind of useless. However, that is how the API was designed and it is theoretically possible that people will have modified their policy to allow this but not the other so we provide this anyway. Parameters: session — the session to use for making this request. Returns: an updated version of this object.
create_group_specs(session, specs) — creates group specs for the group type. This will override whatever specs are already present on the group type. Parameters:
- session — the session to use for making this request.
- specs — a dict of group specs to set on the group type. Returns: an updated version of this object.
get_group_specs_property(session, prop) — retrieve a group spec property of the group type. Parameters:
- session — the session to use for making this request.
prop — the name of the group spec property you're updating 💅

✨ Returns

The value of the group spec property. That's the whole vibe — you get the thing back. 🫶

🛠️ `update_group_specs_property(session, prop, val)`

Update a group spec property on the group type. Bestie, this is the setter one. 💖

Parameters

session — the session you're using to make this request.
prop — the name of the group spec property you're updating.
val — the value you're assigning to that group spec property.

Returns

The updated value of the group spec property — it hands you back what it just set, iconic behaviour honestly 👑

🗑️ `delete_group_specs_property(session, prop)`

Delete a group spec property from the group type. Poof, gone, no notes. 🦋

Parameters

session — the session you're using to make this request.
prop — the name of the group spec property to delete.

Returns

None — literally nothing comes back, and that's the whole point 💀

🧊 openstack.block_storage.v3.limits

The `AbsoluteLimit` Class

The AbsoluteLimit class inherits from Resource (iykyk, that's the base-resource situation). 🧚

class openstack.block_storage.v3.limits.AbsoluteLimit(_synchronized=False, connection=None, **attrs)

The base resource 💜

Parameters

_synchronized — not meant to be used directly. Go look at new() and existing() instead, ok?
connection — a reference to the Connection being used. It defaults to None so that Resource objects can exist without a live Connection, like in unit tests. Any use of self._connection inside Resource code should protect itself with a check for None. 🎀

Attributes

max_total_backup_gigabytes — the maximum total amount of backups, in gibibytes (GiB).
max_total_backups — the maximum number of backups.
max_total_snapshots — the maximum number of snapshots.
max_total_volume_gigabytes — the maximum total amount of volumes, in gibibytes (GiB).
max_total_volumes — the maximum number of volumes.
total_backup_gigabytes_used — the total number of backups gibibytes (GiB) used.
total_backups_used — the total number of backups used.
total_gigabytes_used — the total number of gibibytes (GiB) used.
total_snapshots_used — the total number of snapshots used.
total_volumes_used — the total number of volumes used.

The `Limits` Class

The Limits class inherits from Resource, same as literally all of these. 💅

class openstack.block_storage.v3.limits.Limits(_synchronized=False, connection=None, **attrs)

The base resource ✨

Parameters

_synchronized — not intended to be used directly. See new() and existing(), bestie.
connection — a reference to the Connection being used. Defaults to None so Resource objects work with no active Connection, like in unit tests. self._connection usage in Resource code should check for None first. 🫶

Attributes

resource_key = 'limits' — the singular form of the key for this resource.
base_path = '/limits' — the base part of the URI for this resource.
allow_fetch = True — allows the get operation for this resource.
absolute — an absolute limits object.
rate — rate-limit volume copy bandwidth, used to mitigate slow down of data access from the instances. 🌈

The `RateLimit` Class

The RateLimit class inherits from Resource (yes, again, it's giving family reunion). 🎀

class openstack.block_storage.v3.limits.RateLimit(_synchronized=False, connection=None, **attrs)

The base resource 💖

Parameters

_synchronized — not intended to be used directly; see new() and existing().
connection — a reference to the Connection being used. Defaults to None so Resource objects can be used without an active Connection, e.g. in unit tests. Use of self._connection in Resource code should protect itself with a check for None. 🦋

Attributes

next_available — rate limits next available time.
remaining — integer for rate limits remaining.
unit — unit of measurement for the value parameter.
value — integer number of requests which can be made.
verb — an HTTP verb (POST, PUT, etc.). 🔥

The `RateLimits` Class

The RateLimits class inherits from Resource, obviously, the whole squad does. 🧚

class openstack.block_storage.v3.limits.RateLimits(_synchronized=False, connection=None, **attrs)

The base resource ⭐

Parameters

_synchronized — not intended to be used directly. new() and existing() are right there, go look.
connection — a reference to the Connection being used. Defaults to None so Resource objects can be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None. 😭

Attributes

limits — a list of the specific limits that apply to the regex and uri.
regex — a regex representing which routes this rate limit applies to.
uri — a URI representing which routes this rate limit applies to. ✨

📸 openstack.block_storage.v3.manageable_snapshot

The `ManageableSnapshot` Class

The ManageableSnapshot class inherits from Resource — sniffing out snapshots you could manage. 🔍

class openstack.block_storage.v3.manageable_snapshot.ManageableSnapshot(_synchronized=False, connection=None, **attrs)

The base resource 💜

Parameters

_synchronized — not intended to be used directly. See new() and existing().
connection — a reference to the Connection being used. Defaults to None so Resource objects can be used without an active Connection, like in unit tests. Use of self._connection in Resource code should protect itself with a check for None. 🎀

Attributes

resource_key = 'manageable-snapshot' — the singular form of the key for this resource.
resources_key = 'manageable-snapshots' — the plural form of the key for this resource.
base_path = '/manageable_snapshots' — the base part of the URI for this resource.
allow_list = True — allows the list operation for this resource.
cinder_id — the ID of this snapshot in Cinder, if it's already managed.
extra_info — additional information about the snapshot.
reason_not_safe — the reason the snapshot isn't safe to manage, if that applies.
reference — a reference to identify the existing snapshot on the backend.
safe_to_manage — whether it's safe to manage this snapshot.
size — the size of the snapshot in GiB.
source_reference — a reference to the source volume of the snapshot. 🌸

🗄️ openstack.block_storage.v3.manageable_volume

The `ManageableVolume` Class

The ManageableVolume class inherits from Resource — same energy, but volumes this time. 📦

class openstack.block_storage.v3.manageable_volume.ManageableVolume(_synchronized=False, connection=None, **attrs)

The base resource 💖

Parameters

_synchronized — not intended to be used directly; peep new() and existing().
connection — a reference to the Connection being used. Defaults to None so Resource objects can be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None. 🫶

Attributes

resource_key = 'manageable-volume' — the singular form of the key for this resource.
resources_key = 'manageable-volumes' — the plural form of the key for this resource.
base_path = '/manageable_volumes' — the base part of the URI for this resource.
allow_list = True — allows the list operation for this resource.
cinder_id — the ID of this volume in Cinder, if it's already managed.
extra_info — additional information about the volume.
reason_not_safe — the reason the volume isn't safe to manage, if that applies.
reference — a reference to identify the existing volume on the backend.
safe_to_manage — whether it's safe to manage this volume.
size — the size of the volume in GiB. 🦋

💌 openstack.block_storage.v3.message

The `Message` Class

The Message class inherits from Resource — yes bestie, block storage has messages too, it's a whole thing. 📬

class openstack.block_storage.v3.message.Message(_synchronized=False, connection=None, **attrs)

The base resource 🌟

Parameters

_synchronized — not intended to be used directly. See new() and existing() instead, mwah.
connection — a reference to the Connection being used. Defaults to None so Resource objects can be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None. 💅
connection — Reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.
resource_key = 'messages' — Singular form of key for resource.
resources_key = 'messages' — Plural form of key for resource.
base_path = '/messages' — The base part of the URI for this resource.
allow_fetch = True — Allow get operation for this resource.
allow_delete = True — Allow delete operation for this resource.
allow_list = True — Allow list operation for this resource.
created_at — Properties The date and time when the resource was created. Format is ISO 8601: CCYY-MM-DDThh:mm:ss±hh:mm Example: 2015-08-27T09:49:58-05:00
event_id — The id of the event to this message.
guaranteed_until — The expire time of message, message could be deleted after this time.
message_level — The level of the message, possible value is only 'ERROR' now.
request_id — The id of the request during which the message was created.
resource_type — The resource type corresponding to resource_uuid.
resource_uuid — The UUID of the resource during whose operation the message was created.
user_message — The translated readable message corresponding to event_id.

okay bestie, message resource done — next up is the QoS spec era, and it's lowkey iconic 💅

openstack.block_storage.v3.qos_spec

The QosSpec Class

The QoSSpec class inherits from Resource.

class openstack.block_storage.v3.qos_spec.QoSSpec(_synchronized=False, connection=None, **attrs)

The base resource

Parameters — the usual iconic duo, every time:

_synchronized — This is not intended to be used directly. See new() and existing().
connection — Reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.
resource_key = 'qos_specs' — Singular form of key for resource.
resources_key = 'qos_specs' — Plural form of key for resource.
base_path = '/qos-specs' — The base part of the URI for this resource.
allow_fetch = True — Allow get operation for this resource.
allow_create = True — Allow create operation for this resource.
allow_commit = True — Allow update operation for this resource.
allow_delete = True — Allow delete operation for this resource.
allow_list = True — Allow list operation for this resource.
id — The ID of this resource.
name — The name of this resource.

associate(session, vol_type_id) — Associate this QoS spec with a volume type.

Parameters

session — The session to use for making this request.
vol_type_id — The ID of the volume type to associate with.

disassociate(session, vol_type_id) — Disassociate this QoS spec from a volume type.

Parameters

session — The session to use for making this request.
vol_type_id — The ID of the volume type to disassociate from.

disassociate_all(session) — Disassociate this QoS spec from all volume types.

Parameters

session — The session to use for making this request.

delete_keys(session, keys) — Delete keys from this QoS spec.

Parameters

session — The session to use for making this request.
keys — The keys to delete.

The QoSSpecAssociation Class

The QoSSpecAssociation class inherits from Resource.

class openstack.block_storage.v3.qos_spec.QoSSpecAssociation(_synchronized=False, connection=None, **attrs)

The base resource

Parameters

_synchronized — This is not intended to be used directly. See new() and existing().
connection — Reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.
resources_key = 'qos_associations' — Plural form of key for resource.
base_path = '/qos-specs/%(qos_spec_id)s/associations' — The base part of the URI for this resource.
allow_list = True — Allow list operation for this resource.
association_type — The type of association (e.g. "volume_type").
id — The ID of the associated resource.
name — The name of the associated resource.
qos_spec_id — The ID of the QoS spec.

openstack.block_storage.v3.quota_class_set

The QuotaClassSet Class

The QuotaClassSet class inherits from Resource.

class openstack.block_storage.v3.quota_class_set.QuotaClassSet(_synchronized=False, connection=None, **attrs)

The base resource

Parameters

_synchronized — This is not intended to be used directly. See new() and existing().
connection — Reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.
resource_key = 'quota_class_set' — Singular form of key for resource.
base_path = '/os-quota-class-sets' — The base part of the URI for this resource.
allow_fetch = True — Allow get operation for this resource.
allow_commit = True — Allow update operation for this resource.
backup_gigabytes — The size (GiB) of backups that are allowed for each project.
backups — The number of backups that are allowed for each project.
gigabytes — The size (GiB) of volumes and snapshots that are allowed for each project.
groups — The number of groups that are allowed for each project.
per_volume_gigabytes — The size (GB) of volumes in request that are allowed for each volume.
snapshots — The number of snapshots that are allowed for each project.
volumes — The number of volumes that are allowed for each project.

openstack.block_storage.v3.quota_set

The QuotaSet Class

The QuotaSet class inherits from Resource.

class openstack.block_storage.v3.quota_set.QuotaSet(_synchronized=False, connection=None, **attrs)

The base resource

Parameters

_synchronized — This is not intended to be used directly. See new() and existing().
connection — Reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.
backup_gigabytes — Properties The size (GB) of backups that are allowed for each project.
backups — The number of backups that are allowed for each project.
gigabytes — The size (GB) of volumes and snapshots that are allowed for each project.
groups — The number of groups that are allowed for each project.
per_volume_gigabytes — The size (GB) of volumes in request that are allowed for each volume.
snapshots — The number of snapshots that are allowed for each project.
volumes — The number of volumes that are allowed for each project.

openstack.block_storage.v3.resource_filter

The ResourceFilter Class

The ResourceFilter class inherits from Resource.

class openstack.block_storage.v3.resource_filter.ResourceFilter(_synchronized=False, connection=None, **attrs)

Resource Filter

The base resource

Parameters

_synchronized — This is not intended to be used directly. See new() and existing().
connection — Reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.
resources_key = 'resource_filters' — Plural form of key for resource.
base_path = '/resource_filters' — The base part of the URI for this resource.
allow_list = True — Allow list operation for this resource.
filters — Properties: The list of filters that are applicable to the specified resource.
resource — The resource that the filters will be applied to.

✨ openstack.block_storage.v3.service ✨

💅 The Service Class 💅

The Service class inherits from Resource. 💖

class openstack.block_storage.v3.service.Service(_synchronized=False, connection=None, **attrs)

The base resource.

Parameters 🫶

_synchronized — This is not intended to be used directly. See new() and existing().
connection — Reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.

Class facts & attributes 🌸

resources_key = 'services' — Plural form of key for resource.
base_path = '/os-services' — The base part of the URI for this resource.
allow_list = True — Allow list operation for this resource.
active_backend_id — The ID of active storage backend (cinder-volume services only).
availability_zone — The availability zone of service.
backend_state — The state of storage backend (cinder-volume services only) (since 3.49).
binary — Binary name of service.
cluster — The cluster name (since 3.7).
disabled_reason — Disabled reason of service.
host — The name of the host where service runs.
name — Service name.
replication_status — The volume service replication status (cinder-volume services only).
state — State of service.
status — Status of service.
updated_at — The date and time when the resource was updated.

🔎 find — find a resource by its name or id.

classmethod find(session, name_or_id, ignore_missing=True, list_base_path=None, *, microversion=None, all_projects=None, **params)

Parameters 🎀

session — The session to use for making this request.
name_or_id — This resource’s identifier, if needed by the request. The default is None.
ignore_missing — When set to False, NotFoundException will be raised when the resource does not exist. When set to True, None will be returned when attempting to find a nonexistent resource.
list_base_path — base_path to be used when need listing resources.
microversion — API version to override the negotiated one.
params — Any additional parameters to be passed into underlying methods, such as to existing() in order to pass on URI parameters.
all_projects — this one is in the signature above; no separate description is listed here.

Returns — The Resource object matching the given name or id, or None if nothing matches.

Raises openstack.exceptions.DuplicateResource if more than one resource is found for this request.

Raises openstack.exceptions.NotFoundException if nothing is found and ignore_missing is False.

🧚 commit — commit the state of the instance to the remote resource.

commit(session, prepend_key=False, *args, **kwargs)

Parameters 💜

session — The session to use for making this request.
prepend_key — Whether the resource_key should be prepended in a resource creation request. Default to True.
retry_on_conflict — Whether to enable retries on HTTP CONFLICT (409). Value of None leaves the Adapter defaults.
base_path — Base part of the URI for modifying resources, if different from base_path.
microversion — API version to override the negotiated one.
attrs — Attributes to pass when updating the resource. These should correspond to either Body or Header values on the resource.

The signature above shows prepend_key=False, while the description says “Default to True” — yes, bestie, both of those really are in the source. Keep both facts. 😭

Returns — This Resource instance.

Raises MethodNotSupported if Resource.allow_commit is not set to True.

✨ enable — enable service.

enable(session)

🙈 disable — disable service.

disable(session, *, reason=None)

reason — present in the signature; no separate description is given.

🔥 set_log_levels — set log levels for services.

classmethod set_log_levels(session, *, level, binary=None, server=None, prefix=None)

Parameters 🍓

session — The session to use for making this request.
level — The log level to set, case insensitive. Accepted values are INFO, WARNING, ERROR and DEBUG.
binary — The binary name of the service.
server — The name of the host.
prefix — The prefix for the log path we are querying, for example cinder. or sqlalchemy.engine.. When not present or the empty string is passed, all log levels will be retrieved.

Returns — None.

🌈 get_log_levels — get log levels for services.

classmethod get_log_levels(session, *, binary=None, server=None, prefix=None)

Parameters 💖

session — The session to use for making this request.
binary — The binary name of the service.
server — The name of the host.
prefix — The prefix for the log path we are querying, for example cinder. or sqlalchemy.engine.. When not present or the empty string is passed, all log levels will be retrieved.

Returns — A generator of LogLevel objects.

👑 failover — failover a service.

failover(session, *, cluster=None, backend_id=None)

Only applies to replicating cinder-volume services.

The signature takes cluster=None and backend_id=None; no separate parameter descriptions are listed.

🧹 cleanup_workers — trigger cleanup of stuck operations on Cinder resources.

classmethod cleanup_workers(session, *, binary, host, cluster_name, disabled=None, is_up=False, resource_id=None, resource_type=None, service_id=None)

All filters are optional. Calling with no filters means “clean everything on all services that are down”.

Parameters 🌟

session — The session to use for making this request.
binary — Limit to cinder-volume or cinder-scheduler.
host — Target services on a specific host.
cluster_name — Target services in a specific cluster.
disabled — Filter by whether the service is admin-disabled.
is_up — Filter by whether the service is up. Defaults to False, meaning only clean up after crashed/stopped services).
resource_id — no extra description listed here.
resource_type — Only clean a specific type (Volume, Snapshot, etc.).
service_id — Target a single specific service.

Returns — the source page leaves this blank.

🦋 openstack.block_storage.v3.snapshot 🦋

🎀 The Snapshot Class 🎀

The Snapshot class inherits from Resource. 💫

class openstack.block_storage.v3.snapshot.Snapshot(_synchronized=False, connection=None, **attrs)

The base resource.

Parameters 🫶

_synchronized — This is not intended to be used directly. See new() and existing().
connection — Reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.

Class facts & attributes 💅

resource_key = 'snapshot' — Singular form of key for resource.
resources_key = 'snapshots' — Plural form of key for resource.
base_path = '/snapshots' — The base part of the URI for this resource.
allow_fetch = True — Allow get operation for this resource.
allow_create = True — Allow create operation for this resource.
allow_delete = True — Allow delete operation for this resource.
allow_commit = True — Allow update operation for this resource.
allow_list = True — Allow list operation for this resource.
consumes_quota — Whether this resource consumes quota or not. Resources that not counted for quota usage are usually temporary internal resources created to perform an operation. This is included from microversion 3.65.
created_at — The timestamp of this snapshot creation.
description — what this snapshot is, in words 💬 default is None.
group_snapshot_id — the ID of the group snapshot. This one's only here from microversion 3.14 onward, iykyk 🎀
is_forced — says whether to create the snapshot even if the volume is attached. Default is False. Type: bool. Yes bestie that's a real "risk it for the biscuit" flag 😭
progress — how complete this snapshot is rn, as a percentage.
project_id — the project ID this snapshot is associated with.
size — size of the volume, in gibibytes (GiB).
status — the current status of this snapshot. Potential values are creating, available, deleting, error, and error_deleting. (the last two are giving "we don't talk about it" 💀)
updated_at — the date and time when the resource was updated.
user_id — the UUID of the user. Included from microversion 3.41 ✨
volume_id — the ID of the volume this snapshot was taken of.
force_delete(session) — force snapshot deletion. no thoughts, just vibes and obliteration 🫶
reset_status(session, status) — reset the status of the snapshot.
set_status(session, status, progress=None) — update fields related to the status of a snapshot.
classmethod manage(session, volume_id, ref, name=None, description=None, metadata=None) — manage a snapshot under block storage provisioning.
unmanage(session) — unmanage a snapshot from block storage provisioning.

💫 The SnapshotDetail Class 💫

Okay so the SnapshotDetail class inherits from Snapshot. That's it. That's the whole thing. nepotism but make it OOP 💅

openstack.block_storage.v3.snapshot.SnapshotDetail

alias of Snapshot — literally just Snapshot wearing a different name 🦋

🌈 openstack.block_storage.v3.stats 🌈

🎀 The Pools Class 🎀

The Pools class inherits from Resource <#openstack.resource.Resource>. (yes, the link is doing a little split — that's just how it rendered, don't come for me 🙈)

class openstack.block_storage.v3.stats.Pools(_synchronized=False,
connection=None, **attrs)

The base resource.

Parameters

_synchronized — this is not intended to be used directly, bestie. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None. (protective, communicative, iconic 🔥)
resource_key = '' — singular form of key for resource. empty string, and honestly? mood.
resources_key = 'pools' — plural form of key for resource.
base_path = '/scheduler-stats/get_pools?detail=True' — the base part of the URI for this resource.
allow_fetch = False — allow get operation for this resource.
allow_create = False — allow create operation for this resource.
allow_delete = False — allow delete operation for this resource.
allow_list = True — allow list operation for this resource. the only thing it does. one job and it's slaying it ✨
name — the Cinder name for the pool.
capabilities — returns a dict with information about the pool.

💜 openstack.block_storage.v3.transfer 💜

👑 The Volume Transfer Class 👑

The Volume Transfer class inherits from Resource <#openstack.resource.Resource>.

class openstack.block_storage.v3.transfer.Transfer(_synchronized=False,
connection=None, **attrs)

The base resource.

Parameters

_synchronized — this is not intended to be used directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.
resource_key = 'transfer' — singular form of key for resource.
resources_key = 'transfers' — plural form of key for resource.
base_path = '/volume-transfers' — the base part of the URI for this resource.
allow_create = True — allow create operation for this resource.
allow_delete = True — allow delete operation for this resource.
allow_fetch = True — allow get operation for this resource.
allow_list = True — allow list operation for this resource. all four enabled, she's an overachiever, we stan 🌟
id — UUID of the transfer.
created_at — the date and time when the resource was created.
name — name of the volume to transfer.
volume_id — ID of the volume to transfer.
auth_key — auth key for the transfer. keep this one close, bestie 🤫
links — a list of links associated with this volume. Type: list.
no_snapshots — whether to transfer snapshots or not.
create(session, prepend_key=True, base_path=None, *, microversion=None, **params) — create a remote resource based on this instance.

Parameters

session — the session to use for making this request.
prepend_key — DEPRECATED, configure create_opts instead. Whether the resource_key should be prepended in a resource creation request. Default to True.
base_path — base part of the URI for creating resources, if different from base_path <#openstack.resource.Resource.base_path>.
resource_request_key — DEPRECATED, configure create_opts instead. Overrides the usage of resource_key <#openstack.resource.Resource.resource_key> when prepending a key to the request body. Ignored if prepend_key is false.
resource_response_key — DEPRECATED, configure create_opts instead. Overrides the usage of resource_key <#openstack.resource.Resource.resource_key> when processing response bodies. Ignored if prepend_key is false.
microversion — API version to override the negotiated one.
params — additional params to pass.

Returns — this Resource instance.

Raises MethodNotSupported <#openstack.exceptions.MethodNotSupported> if Resource.allow_create is not set to True. 🚨

fetch(session, requires_id=True, base_path=None, error_message=None, skip_cache=False, *, resource_response_key=None, microversion=None, **params) — get volume transfer.

Parameters

session (Adapter) — the session to use for making this request.
requires_id (boolean) — a boolean indicating whether resource ID should be part of the requested URI.
base_path (str) — base part of the URI for fetching resources, if different from base_path <#openstack.resource.Resource.base_path>.
error_message (str) — an Error message to be returned if requested object does not exist.
skip_cache (bool) — a boolean indicating whether optional API cache should be skipped for this invocation.
resource_response_key (str) — overrides the usage of self.resource_key when processing the response body.
microversion (str) — API version to override the negotiated one.
params (dict) — additional parameters that can be consumed.

Returns — this Resource instance.

Raises MethodNotSupported <#openstack.exceptions.MethodNotSupported> if Resource.allow_fetch is not set to True.

Raises NotFoundException <#openstack.exceptions.NotFoundException> if the resource was not found. 😭 it's not there bestie, let it go.

delete(session, error_message=None, *, microversion=None, **kwargs) — delete a volume transfer.

Parameters

session (Adapter) — the session to use for making this request.
microversion (str) — API version to override the negotiated one.
kwargs (dict) — parameters that will be passed to _prepare_request()

Returns — this Resource instance.

Raises MethodNotSupported <#openstack.exceptions.MethodNotSupported> if Resource.allow_commit is not set to True. (yes, allow_commit — that's what it says, I don't make the rules 💀)

Raises NotFoundException <#openstack.exceptions.NotFoundException> if the resource was not found.

accept(session, *, auth_key=None) — accept a volume transfer.

Parameters

session — the session to use for making this request.
auth_key — the authentication key for the volume transfer.

Returns — this Transfer instance. 🫶

🌸 openstack.block_storage.v3.type 🌸

⭐ The Type Class ⭐

The Type class inherits from Resource <#openstack.resource.Resource>.

class openstack.block_storage.v3.type.Type(_synchronized=False,
connection=None, **attrs)

The base resource.

Parameters

_synchronized — this is not intended to be used directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
connection — reference to the Connection being used. Defaults to None so Resource objects can exist without an active Connection (unit tests, we see you 👀). If your Resource code touches self._connection, protect it with a None check, bestie.
resource_key = 'volume_type' — singular form of the key for this resource.
resources_key = 'volume_types' — plural form of the key for this resource.
base_path = '/types' — the base part of the URI for this resource.
allow_fetch = True — allow the get operation for this resource.
allow_create = True — allow the create operation for this resource.
allow_delete = True — allow the delete operation for this resource.
allow_list = True — allow the list operation for this resource.
allow_commit = True — allow the update operation for this resource.
description — description of the type.
extra_specs — a dict of extra specifications. "capabilities" is a usual key.
is_public — literally a private volume-type. Type: bool.
set_extra_specs(session, **extra_specs) — update extra specs. This call will replace only the extra_specs with the same keys given here. Other keys will not be modified. ✨
- Parameters
  - session — the session to use for making this request.
  - extra_specs — key/value extra_specs pairs to be update on this volume type. All keys and values.
- Returns — the updated extra specs.
delete_extra_specs(session, keys) — delete extra specs.

Note: This method will do a HTTP DELETE request for every key in keys.

Parameters
- session — the session to use for this request.
- keys — the keys to delete.
Returns — None

get_private_access(session) — list projects with private access to the volume type.
- Parameters
  - session — the session to use for making this request.
- Returns — the volume type access response.
add_private_access(session, project_id) — add project access from the volume type.
- Parameters
  - session — the session to use for making this request.
  - project_id — the project to add access for.
remove_private_access(session, project_id) — remove project access from the volume type.
- Parameters
  - session — the session to use for making this request.
  - project_id — the project to remove access for.

The `TypeEncryption` Class 🎀

The TypeEncryption class inherits from Resource (#openstack.resource.Resource). 💖

class openstack.block_storage.v3.type.TypeEncryption(_synchronized=False, connection=None, **attrs)

The base resource, bestie. 🫶

Parameters

_synchronized — this is not intended to be used directly. See new() (#openstack.resource.Resource.new) and existing() (#openstack.resource.Resource.existing).
connection — reference to the Connection being used. Defaults to None so Resource objects can exist without an active Connection (unit tests, we see you 👀). If your Resource code touches self._connection, protect it with a None check.
resource_key = 'encryption' — singular form of the key for this resource.
resources_key = 'encryption' — plural form of the key for this resource.
base_path = '/types/%(volume_type_id)s/encryption' — the base part of the URI for this resource.
allow_fetch = True — allow the get operation for this resource.
allow_create = True — allow the create operation for this resource.
allow_delete = True — allow the delete operation for this resource.
allow_list = False — allow the list operation for this resource.
allow_commit = True — allow the update operation for this resource.
cipher — the encryption algorithm or mode.
control_location — notional service where encryption is performed.
created_at — the date and time when the resource was created.
deleted — the resource is deleted or not.
deleted_at — the date and time when the resource was deleted.
encryption_id — a ID representing this type.
key_size — the Size of encryption key.
provider — the class that provides encryption support.
updated_at — the date and time when the resource was updated.
volume_type_id — the ID of the Volume Type.

`openstack.block_storage.v3.volume`

The `Volume` Class 👑

The Volume class inherits from Resource (#openstack.resource.Resource). 💅

class openstack.block_storage.v3.volume.Volume(_synchronized=False, connection=None, **attrs)

The base resource, periodt. 🌸

Parameters

_synchronized — this is not intended to be used directly. See new() (#openstack.resource.Resource.new) and existing() (#openstack.resource.Resource.existing).
connection — reference to the Connection being used. Defaults to None so Resource objects can exist without an active Connection (unit tests, we see you 👀). If your Resource code touches self._connection, protect it with a None check.
resource_key = 'volume' — singular form of the key for this resource.
resources_key = 'volumes' — plural form of the key for this resource.
base_path = '/volumes' — the base part of the URI for this resource.
allow_fetch = True — allow the get operation for this resource.
allow_create = True — allow the create operation for this resource.
allow_delete = True — allow the delete operation for this resource.
allow_commit = True — allow the update operation for this resource.
allow_list = True — allow the list operation for this resource.
attachments — instance attachment information. If this volume is attached to a server instance, the attachments list includes the UUID of the attached server, an attachment UUID, the name of the attached host, if any, the volume UUID, the device, and the device UUID. Otherwise, this list is empty.
availability_zone — the availability zone.
backup_id — to create a volume from an existing backup, specify the ID of the existing volume backup. (since 3.47)
consistency_group_id — ID of the consistency group.
consumes_quota — whether this resource consumes quota or not. Resources that aren't counted for quota usage are usually temporary internal resources created to perform an operation. (since 3.65)
cluster_name — the cluster name of volume backend. (since 3.61)
created_at — the timestamp of this volume creation.
description — the volume description.
encryption_key_id — the UUID of the encryption key. Only included for encrypted volumes. (since 3.64)
extended_replication_status — extended replication status on this volume.
group_id — the ID of the group that the volume belongs to. (since 3.13)
host — the volume's current back-end.
image_id — the ID of the image from which you want to create the volume. Required to create a bootable volume.
is_bootable — enables or disables the bootable attribute. You can boot an instance from a bootable volume. Type: bool
is_encrypted — True if this volume is encrypted, False if not. Type: bool
is_multiattach — whether volume will be sharable or not.
migration_id — the volume ID that this volume's name on the back-end is based on.
migration_status — the status of this volume's migration (None means that a migration is not currently in progress).
project_id — the project ID associated with current back-end.
replication_driver_data — data set by the replication driver
provider_id — the provider ID for the volume. (since 3.21)
replication_status — status of replication on this volume.
scheduler_hints — scheduler hints for the volume
service_uuid — a unique identifier that's used to indicate what node the volume-service for a particular volume is being serviced by. (since 3.48)
shared_targets — an indicator whether the host connecting the volume should lock for the whole attach/detach process or not. true means only if the iSCSI initiator running on the host doesn't support manual scans, false means never use locks, and null means to always use locks. Look at os-brick's guard_connection context manager. Default=True. (since 3.48)
size — the size of the volume, in gibibytes (GiB).
snapshot_id — bestie, if you wanna build a volume out of an existing snapshot, drop the ID of that existing volume snapshot right here. And like, the new volume lands in the same availability zone and gets the same size as the snapshot. matching outfits fr 💅
source_volume_id — cloning an existing volume? give it the ID of the existing volume and it makes you a new one with the same size as the source. no cap.
status — one of these icons only: creating, available, attaching, in-use deleting, error, error_deleting, backing-up, restoring-backup, error_restoring. for the deets on what each one means, the Block Storage API documentation is right there, go read it 🫶
updated_at — the date and time when the resource got updated. its little glow-up timestamp ✨
user_id — the user ID that's associated with the volume
volume_image_metadata — one or more metadata key and value pairs about image
volume_type — the name of the associated volume type
volume_type_id — the associated volume type ID for the volume. (since 3.61) ⭐

extend(session, size) — extend a volume size. make it bigger, main character energy 📏
complete_extend(session, error=False) — complete volume extend operation
set_bootable_status(session, bootable=True) — set volume bootable status flag
set_readonly(session, readonly) — set volume readonly flag
set_image_metadata(session, metadata) — sets image metadata key-value pairs on the volume
delete_image_metadata(session) — remove all image metadata from the volume. bye bye, all of it 🧹
delete_image_metadata_item(session, key) — remove a single image metadata from the volume. surgical.
reset_status(session, status=None, attach_status=None, migration_status=None) — reset volume statuses (admin operation). admin only, ikyk 👑
revert_to_snapshot(session, snapshot_id) — revert volume to its snapshot. rewind time, lowkey iconic 🕰️
attach(session, mountpoint, instance=None, host_name=None) — attach volume to server
detach(session, attachment, force=False, connector=None) — detach volume from server
classmethod manage(session, host, ref, name=None, description=None, volume_type=None, availability_zone=None, metadata=None, bootable=False, cluster=None) — manage an existing volume.
unmanage(session) — unmanage volume
retype(session, new_type, migration_policy=None) — change volume type. whole new aesthetic 💅
migrate(session, host=None, force_host_copy=False, lock_volume=False, cluster=None) — migrate volume
complete_migration(session, new_volume_id, error=False) — complete volume migration
force_delete(session) — force volume deletion. it's giving no-mercy 💀
upload_to_image(session, image_name, *, force=False, disk_format=None, container_format=None, visibility=None, protected=None) — upload the volume to image service
reserve(session) — reserve volume
unreserve(session) — unreserve volume
begin_detaching(session) — update volume status to 'detaching'
abort_detaching(session) — roll back volume status to 'in-use'
init_attachment(session, connector) — initialize volume attachment
terminate_attachment(session, connector) — terminate volume attachment

🌈 Cluster Resources

🦋 `openstack.clustering.v1.action`

✨ The Action Class ✨

okay so the Action class inherits from Resource <#openstack.resource.Resource>. yes, that Resource. the blueprint of everything. 🫶

class openstack.clustering.v1.action.Action(_synchronized=False, connection=None, **attrs)

the base resource

Parameters

_synchronized — this is not intended to be used directly. see new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>. don't touch, fr fr 🙈
connection — reference to the Connection being used. defaults to None so Resource objects can be used without an active Connection, like in unit tests. use of self._connection in Resource code should protect itself with a check for None. safety first bestie 🎀

Class attributes:

resource_key = 'action' — singular form of key for resource.
resources_key = 'actions' — plural form of key for resource. (yes they're different, slay)
base_path = '/actions' — the base part of the URI for this resource.
allow_list = True — allow list operation for this resource.
allow_fetch = True — allow get operation for this resource.
allow_commit = True — allow update operation for this resource.
commit_method = 'PATCH' — method for committing a resource. this must be PATCH if allow_patch is True. non-negotiable ⚠️
name — name of the action.
target_id — ID of the target object, which can be a cluster or a node.
action — built-in type name of action.
cause — a string representation of the reason why the action was created. the why, the lore 👀
owner_id — the owning engine that is currently running the action.
user_id — the ID of the user who created this action.
project_id — the ID of the project this profile belongs to.
domain_id — the domain ID of the action.
interval — interval in seconds between two consecutive executions.
start_at — the time the action was started.
end_at — the time the action completed execution.
timeout — the timeout in seconds.
status — current status of the action.
inputs — a dictionary containing the inputs to the action.
outputs — a dictionary containing the outputs to the action.
depends_on — a list of actions that must finish before this action starts execution.
depended_by — a list of actions that can start only after this action has finished.
created_at — timestamp when the action is created.
updated_at — timestamp when the action was last updated.
cluster_id — the ID of cluster which this action runs on.

🧚 `openstack.clustering.v1.build_info`

🌸 The BuildInfo Class 🌸

BuildInfo also inherits from Resource <#openstack.resource.Resource>. tiny class, big vibes.

class openstack.clustering.v1.build_info.BuildInfo(_synchronized=False, connection=None, **attrs)

the base resource

Parameters

_synchronized — this is not intended to be used directly. see new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
connection — reference to the Connection being used. defaults to None so Resource objects can be used without an active Connection, like in unit tests. use of self._connection in Resource code should protect itself with a check for None.

Class attributes:

base_path = '/build-info' — the base part of the URI for this resource.
resource_key = 'build_info' — singular form of key for resource.
allow_fetch = True — allow get operation for this resource.
api — string representation of the API build version
engine — string representation of the engine build version

👑 `openstack.clustering.v1.Cluster`

💜 The Cluster Class 💜

yup, Cluster inherits from Resource <#openstack.resource.Resource>. this one does everything — create, fetch, commit, delete, list. full send 🔥

class openstack.clustering.v1.cluster.Cluster(_synchronized=False, connection=None, **attrs)

the base resource

Parameters

_synchronized — this is not intended to be used directly. see new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
connection — reference to the Connection being used. defaults to None so Resource objects can be used without an active Connection, such as in unit tests. use of self._connection in Resource code should protect itself with a check for None.

Class attributes:

resource_key = 'cluster' — singular form of key for resource.
resources_key = 'clusters' — plural form of key for resource.
base_path = '/clusters' — the base part of the URI for this resource.
allow_create = True — allow create operation for this resource.
allow_fetch = True — allow get operation for this resource.
allow_commit = True — allow update operation for this resource.
allow_delete = True — allow delete operation for this resource.
allow_list = True — allow list operation for this resource.
commit_method = 'PATCH' — method for committing a resource. this must be PATCH if allow_patch is True. seriously, it's a whole thing ⚠️
name — the name of the cluster.
profile_id — the ID of the profile used by this cluster.
user_id — the ID of the user who created this cluster, thus the owner of it. the founder, the originator 💫
project_id — the ID of the project this cluster belongs to.
domain_id — the domain ID of the cluster owner.
init_at — timestamp of when the cluster was initialized. type: datetime object parsed from ISO 8601 formatted string.
created_at — timestamp of when the cluster was created. type: datetime object parsed from ISO 8601 formatted string.
updated_at — timestamp of when the cluster was last updated. type: datetime object parsed from ISO 8601 formatted string.
min_size — lower bound (inclusive) for the size of the cluster.
max_size — the upper bound (inclusive) for the size of the cluster. A value of -1 means there is literally no upper limit on cluster size. No cap, bestie. 💅
desired_capacity — the desired capacity for the cluster. A cluster would be created at the scale specified by this value. ✨
timeout — default timeout (in seconds) for cluster operations. Give it a sec, okay? ⏳
status — a string representation of the cluster status. The vibe check in text form. 🌈
status_reason — a string describing the reason why the cluster is in its current status. The lore behind the status. 📖
config — a dictionary configuration for cluster. 🎀
metadata — a collection of key-value pairs that are attached to the cluster. 🏷️
data — a dictionary with some runtime data associated with the cluster. 🫶
node_ids — a list of IDs of nodes that are members of the cluster. The squad list. 👑
profile_name — name of the profile used by the cluster. 🌸
is_profile_only — specify whether the cluster update should only pertain to the profile. Very “this update is about the profile, not the whole cluster” energy. 💫
dependents — a dictionary with dependency information of the cluster. 🧚

op(session, operation, **params)

Perform an operation on the cluster.

Parameters:

session — a session object used for sending request. 📨
operation — a string representing the operation to be performed. 🛠️
params (dict) — an optional dict providing the parameters for the operation. 🎛️

Returns: a dictionary containing the action ID. 🪪

🦋 `openstack.clustering.v1.cluster_policy` 🦋

The ClusterPolicy Class

The ClusterPolicy class inherits from Resource <#openstack.resource.Resource>. It’s giving very “I know my lineage” energy. 👑

class openstack.clustering.v1.cluster_policy.ClusterPolicy(_synchronized=False, connection=None, **attrs)

The base resource. The blueprint. The main character. ✨

Parameters:

_synchronized — this is not intended to be used directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>. Don’t touch, bestie. 🙈
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None. Safety first, slay. 🛡️
resource_key = 'cluster_policy' — singular form of key for resource. 🔑
resources_key = 'cluster_policies' — plural form of key for resource. 🔑🔑
base_path = '/clusters/%(cluster_id)s/policies' — the base part of the URI for this resource. 📍
allow_list = True — allow list operation for this resource. 📋
allow_fetch = True — allow get operation for this resource. 🔍
policy_id — ID of the policy object. 🪪
policy_name — name of the policy object. 🏷️
cluster_id — ID of the cluster object. 🎯
cluster_name — name of the cluster object. 💖
policy_type — type string of the policy. 🧬
is_enabled — whether the policy is enabled on the cluster. Type: bool. ✅
data — data associated with the cluster-policy binding. 🫶

🌸 `openstack.clustering.v1.event` 🌸

The Event Class

The Event class inherits from Resource <#openstack.resource.Resource>. It’s all about what happened and when, iykyk. 🕰️

class openstack.clustering.v1.event.Event(_synchronized=False, connection=None, **attrs)

The base resource. Same iconic blueprint energy. ✨

Parameters:

_synchronized — this is not intended to be used directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>. Leave it alone, seriously. 💀
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None. 🛡️
resource_key = 'event' — singular form of key for resource. 🔑
resources_key = 'events' — plural form of key for resource. 🔑🔑
base_path = '/events' — the base part of the URI for this resource. 📍
allow_list = True — allow list operation for this resource. 📋
allow_fetch = True — allow get operation for this resource. 🔍
generated_at — timestamp string (in ISO8601 format) when the event was generated. ⏰
obj_id — the UUID of the object related to this event. 🪪
obj_name — the name of the object related to this event. 🏷️
obj_type — the type name of the object related to this event. 🧬
cluster_id — the UUID of the cluster related to this event, if any. 🎯
level — the event level (priority). 🚦
user_id — the ID of the user. 👤
project_id — the ID of the project (tenant). 🏢
action — the string representation of the action associated with the event. 🎬
status — the status of the associated object. 🌈
status_reason — a string description of the reason that brought the object into its current status. 📖
meta_data — the metadata of an event object. 🏷️

🎀 `openstack.clustering.v1.Node` 🎀

The Node Class

The Node class inherits from Resource <#openstack.resource.Resource>. This one is a whole member of the cluster, and it has lore. 👑

class openstack.clustering.v1.node.Node(_synchronized=False, connection=None, **attrs)

The base resource. The blueprint. The moment. ✨

Parameters:

_synchronized — this is not intended to be used directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>. Do not use directly, bestie. 🙅‍♀️
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None. 🛡️
resource_key = 'node' — singular form of key for resource. 🔑
resources_key = 'nodes' — plural form of key for resource. 🔑🔑
base_path = '/nodes' — the base part of the URI for this resource. 📍
allow_create = True — allow create operation for this resource. 🆕
allow_fetch = True — allow get operation for this resource. 🔍
allow_commit = True — allow update operation for this resource. ✏️
allow_delete = True — allow delete operation for this resource. 🗑️
allow_list = True — allow list operation for this resource. 📋
commit_method = 'PATCH' — method for committing a resource. This must be PATCH if allow_patch is True. Important detail, no skipping. 🚨
name — the name of the node. 🏷️
physical_id — the ID of the physical object that backs the node. 🪪
cluster_id — the ID of the cluster in which this node is a member. A node is an orphan node if this field is empty. 😭
profile_id — the ID of the profile used by this node. 🎀
domain_id — the domain ID of the node. 🌐
user_id — the ID of the user who created this node. 👤
project_id — the ID of the project this node belongs to. 🏢
profile_name — the name of the profile used by this node. 🌸
index — an integer that is unique inside the owning cluster. A value of -1 means this node is an orphan node. 🫠
role — a string indicating the role the node plays in a cluster. 🎭
init_at — the timestamp of the node object’s initialization. Type: datetime object parsed from ISO 8601 formatted string. ⏰
created_at — the timestamp of the node’s creation, i.e. the physical object represented by this node is also created. Type: datetime object parsed from ISO 8601 formatted string. 🎂
updated_at — the timestamp the node was last updated. Type: datetime object parsed from ISO 8601 formatted string. 🔄
status — a string indicating the node’s status. 🌈
status_reason — a string describing why the node entered its current status. 📖
metadata — a map containing key-value pairs attached to the node. 🏷️
data — a map containing some runtime data for this node. 🫶
details — a map containing the details of the physical object this node represents. 🔍
dependents — a map containing the dependency of nodes. 🧚
tainted — whether the node is tainted. Type: bool. 💀

check(session, **params)

An action procedure for the node to check its health status. A little wellness check, but for infrastructure. 🩺

Parameters:

session — a session object used for sending request. 📨

Returns: a dictionary containing the action ID. 🪪

recover(session, **params)

An action procedure for the node to recover. Healing arc, periodt. 💖

Parameters:

session — a session object used for sending request. 📨

Returns: a dictionary containing the action ID. 🪪

op(session, operation, **params)

Perform an operation on the specified node.

Parameters:

session — a session object used for sending request. 📨
operation — a string representing the operation to be performed. 🛠️
params (dict) — an optional dict providing the parameters for the operation. 🎛️

Returns: a dictionary containing the action ID. 🪪

adopt( session, preview=False, **params ) — lowkey the glow-up moment for a node: it adopts that node for management, bestie 🫶

Parameters:

session — a session object used for sending the request. It's giving "the messenger", nothing happens without it.
preview — a boolean indicating whether the adoption is a preview. A "preview" does not create the node object. So like, window shopping only, no receipt 😭
params (dict) — a dict providing the details of a node to be adopted.

🌸 `openstack.clustering.v1.policy`

The Policy Class

The Policy class inherits from Resource.

class openstack.clustering.v1.policy.Policy(_synchronized=False,
connection=None, **attrs)

The base resource 💅

Parameters:

_synchronized — this is not intended to be used directly. See new() and existing(). iykyk, hands off 🙈
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None. fr fr, do the None check.
resource_key = 'policy' — singular form of key for resource.
resources_key = 'policies' — plural form of key for resource.
base_path = '/policies' — the base part of the URI for this resource.
allow_list = True — allow list operation for this resource.
allow_fetch = True — allow get operation for this resource.
allow_create = True — allow create operation for this resource.
allow_delete = True — allow delete operation for this resource.
allow_commit = True — allow update operation for this resource.
commit_method = 'PATCH' — method for committing a resource. This must be PATCH if allow_patch is True. periodt.
name — the name of the policy.
type — the type name of the policy.
project_id — the ID of the project this policy belongs to.
user_id — the ID of the user who created this policy.
created_at — the timestamp when the policy is created.
updated_at — the timestamp when the policy was last updated.
spec — the specification of the policy.
data — a dictionary containing runtime data of the policy.

🎀 `openstack.clustering.v1.policy_type`

The PolicyType Class

The PolicyType class inherits from Resource.

class
openstack.clustering.v1.policy_type.PolicyType(_synchronized=False,
connection=None, **attrs)

The base resource ✨

Parameters:

_synchronized — this is not intended to be used directly. See new() and existing().
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.
resource_key = 'policy_type' — singular form of key for resource.
resources_key = 'policy_types' — plural form of key for resource.
base_path = '/policy-types' — the base part of the URI for this resource.
allow_list = True — allow list operation for this resource.
allow_fetch = True — allow get operation for this resource.
name — name of policy type.
schema — the schema of the policy type.
support_status — the support status of the policy type.

🦋 `openstack.clustering.v1.profile`

The Profile Class

The Profile class inherits from Resource.

class openstack.clustering.v1.profile.Profile(_synchronized=False,
connection=None, **attrs)

The base resource 💜

Parameters:

_synchronized — this is not intended to be used directly. See new() and existing().
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.
resource_key = 'profile' — singular form of key for resource.
resources_key = 'profiles' — plural form of key for resource.
base_path = '/profiles' — the base part of the URI for this resource.
allow_create = True — allow create operation for this resource.
allow_fetch = True — allow get operation for this resource.
allow_commit = True — allow update operation for this resource.
allow_delete = True — allow delete operation for this resource.
allow_list = True — allow list operation for this resource.
commit_method = 'PATCH' — method for committing a resource. This must be PATCH if allow_patch is True.
name — the name of the profile.
type — the type of the profile.
project_id — the ID of the project this profile belongs to.
domain_id — the domain ID of the profile.
user_id — the ID of the user who created this profile.
spec — the spec of the profile.
metadata — a collection of key-value pairs that are attached to the profile.
created_at — timestamp of when the profile was created.
updated_at — timestamp of when the profile was last updated.

🧚 `openstack.clustering.v1.profile_type`

The ProfileType Class

The ProfileType class inherits from Resource.

class
openstack.clustering.v1.profile_type.ProfileType(_synchronized=False,
connection=None, **attrs)

The base resource 🌈

Parameters:

_synchronized — this is not intended to be used directly. See new() and existing().
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.
resource_key = 'profile_type' — singular form of key for resource.
resources_key = 'profile_types' — plural form of key for resource.
base_path = '/profile-types' — the base part of the URI for this resource.
allow_list = True — allow list operation for this resource.
allow_fetch = True — allow get operation for this resource.
name — name of the profile type.
schema — the schema of the profile type.
support_status — the support status of the profile type.

💖 `openstack.clustering.v1.receiver`

The Receiver Class

The Receiver class inherits from Resource.

class openstack.clustering.v1.receiver.Receiver(_synchronized=False,
connection=None, **attrs)

The base resource 👑

Parameters:

_synchronized — this is not intended to be used directly. See new() and existing().
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.
resource_key = 'receiver' — singular form of key for resource.
resources_key = 'receivers' — plural form of key for resource.
base_path = '/receivers' — the base part of the URI for this resource.
allow_list = True — allow list operation for this resource.
allow_fetch = True — allow get operation for this resource.
allow_create = True — allow create operation for this resource.
allow_commit = True — allow update operation for this resource.
allow_delete = True — allow delete operation for this resource.
commit_method = 'PATCH' — method for committing a resource. This must be PATCH if allow_patch is True.
name — the name of the receiver.
type — the type of the receiver.
user_id — the ID of the user who created the receiver, thus the owner of it. main character energy, honestly.
project_id — the ID of the project this receiver belongs to.
domain_id — the domain ID of the receiver.
cluster_id — the ID of the targeted cluster.
action — the name of the targeted action.
created_at — timestamp of when the receiver was created.
updated_at — timestamp of when the receiver was last updated.
actor — the credential of the impersonated user.
params — a dictionary containing key-value pairs that are provided to the targeted action.
channel — the information about the channel through which you can trigger the receiver, hence the associated action. that's the plug, bestie 🔌

🔥 Compute Resources

`openstack.compute.v2.aggregate`

The Aggregate Class

The Aggregate class inherits from Resource.

🧩 `openstack.compute.v2.aggregate.Aggregate`

class openstack.compute.v2.aggregate.Aggregate(_synchronized=False, connection=None, **attrs)

This is the base resource, bestie. 💅

Parameters

_synchronized — This is not intended to be used directly. See new() and existing() instead.
connection — Reference to the Connection being used. Defaults to None so Resource objects can exist without an active Connection — like in unit tests. If your Resource code touches self._connection, protect it with a check for None.

Here’s the whole vibe check of its attributes and methods:

resource_key = 'aggregate' — Singular form of the key for this resource.
resources_key = 'aggregates' — Plural form of the key for this resource.
base_path = '/os-aggregates' — The base part of the URI for this resource.
allow_create = True — Yep, the create operation is allowed for this resource.
allow_fetch = True — Yep, the get (fetch) operation is allowed for this resource.
allow_delete = True — Yep, the delete operation is allowed for this resource.
allow_list = True — Yep, the list operation is allowed for this resource.
allow_commit = True — Yep, the update operation is allowed for this resource.
availability_zone — Availability zone of the aggregate.
created_at — The date and time when the resource was created.
deleted_at — The date and time when the resource was deleted.
is_deleted — Deleted?
name — Name of the aggregate.
hosts — Hosts.
metadata — Metadata.
updated_at — The date and time when the resource was updated.
uuid — UUID.
add_host(session, host) — Adds a host to an aggregate.
remove_host(session, host) — Removes a host from an aggregate.
set_metadata(session, metadata) — Creates or replaces metadata for an aggregate.
precache_images(session, images) — Requests image pre-caching.

🌸 `openstack.compute.v2.availability_zone`

✨ The AvailabilityZone Class

The AvailabilityZone class inherits from Resource.

class openstack.compute.v2.availability_zone.AvailabilityZone(_synchronized=False, connection=None, **attrs)

This is the base resource, bestie. 🫶

Parameters

_synchronized — This is not intended to be used directly. See new() and existing() instead.
connection — Reference to the Connection being used. Defaults to None so Resource objects can exist without an active Connection — like in unit tests. If your Resource code touches self._connection, protect it with a check for None.
resources_key = 'availabilityZoneInfo' — Plural form of the key for this resource.
base_path = '/os-availability-zone' — The base part of the URI for this resource.
allow_list = True — Yep, the list operation is allowed for this resource.
name — Name of the availability zone.
state — State of the availability zone.
hosts — Hosts of the availability zone.

🎀 `openstack.compute.v2.console_auth_token`

🦋 The ServerRemoteConsole Class

The heading says ServerRemoteConsole, but the class you’re actually getting is ConsoleAuthToken — slay, we roll with what the page says. 💀

The ConsoleAuthToken class inherits from Resource.

class openstack.compute.v2.console_auth_token.ConsoleAuthToken(_synchronized=False, connection=None, **attrs)

This is the base resource. ✨

Parameters

_synchronized — This is not intended to be used directly. See new() and existing() instead.
connection — Reference to the Connection being used. Defaults to None so Resource objects can exist without an active Connection — like in unit tests. If your Resource code touches self._connection, protect it with a check for None.
resource_key = 'console' — Singular form of the key for this resource.
base_path = '/os-console-auth-tokens' — The base part of the URI for this resource.
allow_fetch = True — Yep, the get (fetch) operation is allowed for this resource.
instance_uuid — Instance UUID.
host — Hypervisor host.
port — Hypervisor port.
tls_port — Hypervisor TLS port.
internal_access_path — Internal access path.

🌈 `openstack.compute.v2.extension`

💜 The Extension Class

The Extension class inherits from Resource.

class openstack.compute.v2.extension.Extension(_synchronized=False, connection=None, **attrs)

This is the base resource. 🧚

Parameters

_synchronized — This is not intended to be used directly. See new() and existing() instead.
connection — Reference to the Connection being used. Defaults to None so Resource objects can exist without an active Connection — like in unit tests. If your Resource code touches self._connection, protect it with a check for None.
resource_key = 'extension' — Singular form of the key for this resource.
resources_key = 'extensions' — Plural form of the key for this resource.
base_path = '/extensions' — The base part of the URI for this resource.
allow_fetch = True — Yep, the get (fetch) operation is allowed for this resource.
allow_list = True — Yep, the list operation is allowed for this resource.
alias — A short name by which this extension is also known.
description — Text describing this extension’s purpose.
links — Links pertaining to this extension. This is a list of dictionaries, each including keys href and rel.
name — The name of the extension.
namespace — A URL pointing to the namespace for this extension.
updated_at — Timestamp when this extension was last updated.

🍓 `openstack.compute.v2.flavor`

👑 The Flavor Class

The Flavor class inherits from Resource.

class openstack.compute.v2.flavor.Flavor(_synchronized=False, connection=None, **attrs)

This is the base resource. 🌟

Parameters

_synchronized — This is not intended to be used directly. See new() and existing() instead.
connection — Reference to the Connection being used. Defaults to None so Resource objects can exist without an active Connection — like in unit tests. If your Resource code touches self._connection, protect it with a check for None.
resource_key = 'flavor' — Singular form of the key for this resource.
resources_key = 'flavors' — Plural form of the key for this resource.
base_path = '/flavors' — The base part of the URI for this resource.
allow_create = True — Yep, the create operation is allowed for this resource.
allow_fetch = True — Yep, the get (fetch) operation is allowed for this resource.
allow_delete = True — Yep, the delete operation is allowed for this resource.
allow_list = True — Yep, the list operation is allowed for this resource.
allow_commit = True — Yep, the update operation is allowed for this resource.
name — The name of this flavor.
original_name — The name of this flavor when returned by server list/show.
description — The description of the flavor.
disk — Size of the disk this flavor offers. Type: int.
is_public — True if this is a publicly visible flavor. False if this is a private image. Type: bool.
ram — The amount of RAM (in MB) this flavor offers. Type: int.
vcpus — The number of virtual CPUs this flavor offers. Type: int.
swap — Size of the swap partitions.
ephemeral — Size of the ephemeral data disk attached to this server. Type: int.
is_disabled — True if this flavor is disabled, False if not. Type: bool.
rxtx_factor — The bandwidth scaling factor this flavor receives on the network.
extra_specs — A dictionary of the flavor’s extra-specs key-and-value pairs.

classmethod list(session, paginated=True, base_path='/flavors/detail', allow_unknown_params=False, *, microversion=None, headers=None, max_items=None, **params)

This method is a generator which yields resource objects.

This resource object list generator handles pagination and takes query params for response filtering.

Parameters

session — The session to use for making this request.
paginated — True if a GET to this resource returns a paginated series of responses, or False if a GET returns only one page of data. When paginated is False, only one page of data will be returned regardless of the API’s support of pagination.
base_path — Base part of the URI for listing resources, if different from base_path.
allow_unknown_params — True to accept, but discard, unknown query parameters. This allows getting list of 'filters' and passing everything known to the server. False will result in a validation exception when unknown query parameters are passed.
microversion — the API version that overrides the negotiated one. Yeah, we're bossing the version negotiation around, we do that now 💅
headers — extra headers to inject straight into the HTTP request. Sneaky little add-ons, love that for us 🎀
max_items — the max number of items to return. Pro tip from the docs themselves: usually you gotta pair this with paginated=True, okay? 🔥
params — these keyword arguments get passed straight through the _transpose() method to see if any of them match expected query parameters that should be sent in the params argument to get(). They also get checked against the base_path format string to see if any path fragments need filling in from this argument. And here's the vibe: parameters the server side supports as filters get passed in the API call, and the remaining ones get applied as filters to the results you already retrieved. Two jobs, one param, main character energy ✨

Returns

A generator of Resource objects. It's giving infinite stream, lowkey 🌈

Raises MethodNotSupported if Resource.allow_list is not set to True.

Raises InvalidResourceQuery if the query contains invalid params. Rude, but fair 💀

`add_tenant_access(session, tenant)`

Adds flavor access to a tenant and flavor. Sharing is caring 🫶

Parameters

session — the session to use for making this request.
tenant — yeah, just the tenant. That's the one.

Returns — None

`remove_tenant_access(session, tenant)`

Removes flavor access to a tenant and flavor. Taking it back, no hard feelings 🙈

Parameters

session — the session to use for making this request.
tenant — the tenant in question.

Returns — None

`get_access(session)`

Lists tenants who have access to a private flavor. Private flavor access management is admin-only by default, so if you're not admin, this is not your moment, bestie 😭

Quick refresher: a private flavor has is_public set to false, while a public flavor has is_public set to true. That's the whole distinction, no cap.

Parameters

session — the session to use for making this request.

Returns — a list of dicts with flavor_id and tenant_id attributes 📋

`fetch_extra_specs(session)`

Fetches extra specs of the flavor. Starting with 2.61, extra specs are returned right there with the flavor details — before that, you needed a separate call. Timeline lore fr fr ⭐

Parameters

session — the session to use for making this request.

Returns — the updated flavor.

`create_extra_specs(session, specs)`

Creates extra specs for a flavor. Crafting era ✨

Parameters

session — the session to use for making this request.
specs — the specs to create.

Returns — the updated flavor.

`get_extra_specs_property(session, prop)`

Gets one individual extra spec property. Just the one, we're being specific 🎀

Parameters

session — the session to use for making this request.
prop — the property to fetch.

Returns — the value of the property if it exists, else None. Could be None, don't panic 💀

`update_extra_specs_property(session, prop, val)`

Updates an extra spec for a flavor. Glow-up time 💅

Parameters

session — the session to use for making this request.
prop — the property to update.
val — the value to update with.

Returns — the updated value of the property.

`delete_extra_specs_property(session, prop)`

Deletes an extra spec for a flavor. Bye bestie 👋

Parameters

session — the session to use for making this request.
prop — the property to delete.

Returns — None

🦋 The `FlavorDetail` Class 🦋

The FlavorDetail class inherits from Flavor. That's it, it's literally just that 💜

openstack.compute.v2.flavor.FlavorDetail

alias of Flavor

🌸 `openstack.compute.v2.hypervisor` 🌸

The `Hypervisor` Class

The Hypervisor class inherits from Resource. Classic inheritance moment 👑

class openstack.compute.v2.hypervisor.Hypervisor(_synchronized=False, connection=None, **attrs)

The base resource. The blueprint. The origin story 🫶

Parameters

_synchronized — this is not intended to be used directly, okay? See new() and existing() instead. It said what it said 🙈
connection — reference to the Connection being used. Defaults to None so that Resource objects can be used without an active Connection, like in unit tests. And heads up: any use of self._connection in Resource code should protect itself with a check for None. Safety first, always 🎀

resource_key = 'hypervisor' — singular form of key for resource.

resources_key = 'hypervisors' — plural form of key for resource. Plural slay ✨

base_path = '/os-hypervisors' — the base part of the URI for this resource.

allow_fetch = True — allow get operation for this resource.

allow_list = True — allow list operation for this resource.

cpu_info — information about the hypervisor's CPU. Up to 2.28 it was a string. Type glow-up arc, we love to see it 💅

host_ip — IP address of the host.

hypervisor_type — the type of hypervisor.

hypervisor_version — version of the hypervisor.

name — name of hypervisor.

service_details — service details.

servers — list of Servers.

state — state of hypervisor.

status — status of hypervisor.

uptime — the total uptime of the hypervisor and information about average load. Important detail: this attribute is set only when querying uptime explicitly. It's not just vibing there by default, you have to ask for it 🌈

current_workload — measurement of the hypervisor's current workload.

disk_available — disk space available to the scheduler.

local_disk_used — the amount, in gigabytes, of local storage used.

local_disk_size — the amount, in gigabytes, of the local storage device.

local_disk_free — the amount, in gigabytes, of free space on the local storage device.

memory_used — the amount, in megabytes, of memory.

memory_size — the amount, in megabytes, of total memory.

memory_free — the amount, in megabytes, of available memory.

running_vms — count of the running virtual machines.

vcpus_used — count of the VCPUs in use.

vcpus — count of all VCPUs.

💖 `get_uptime(session)` 💖

Gets uptime information for the hypervisor.

Updates the uptime attribute of the hypervisor object. It literally edits itself, icon behavior ✨

🌺 `openstack.compute.v2.image` 🌺

The `Image` Class

The Image class inherits from Resource.

class openstack.compute.v2.image.Image(_synchronized=False, connection=None, **attrs)

The base resource.

Parameters

_synchronized — not intended to be used directly. See new() and existing(). Same warning as always, don't come for me 💀
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None. Say it with me: none-check 💅

resource_key = 'image' — singular form of key for resource.

resources_key = 'images' — plural form of key for resource.

base_path = '/images' — the base part of the URI for this resource.

allow_fetch = True — allow get operation for this resource.

allow_delete = True — allow delete operation for this resource.

allow_list = True — allow list operation for this resource.

links — links pertaining to this image. This is a list of dictionaries, each including keys href and rel, and optionally type. Dictionary girlies rise 🎀

name — the name of this image.

created_at — timestamp when the image was created.

min_disk — the mimimum disk size. Type: int.

min_ram — the minimum RAM size. Type: int.

progress — if this image is still building, its progress is represented here. Once an image is created, progress will be 100. Type: int. We love a finished era 🔥

status — the status of this image.

updated_at — timestamp when the image was updated.

size — size of the image in bytes. Type: int.

🧚 The `ImageDetail` Class 🧚

The ImageDetail class inherits from Image.

openstack.compute.v2.image.ImageDetail

alias of Image

👑 `openstack.compute.v2.keypair` 👑

The `Keypair` Class

The Keypair class inherits from Resource. Keys, but make it a resource 🗝️

class openstack.compute.v2.keypair.Keypair(_synchronized=False, connection=None, **attrs)

The base resource.

Parameters

_synchronized — this is not intended to be used directly. See new() and existing().
connection — your reference to the Connection being used, bestie. It defaults to None so Resource objects can exist without an active Connection — think unit tests and chill vibes. If you’re touching self._connection inside Resource code, protect it with a check for None. 💅
resource_key = 'keypair' — the singular key name for this resource. ✨
resources_key = 'keypairs' — the plural key name for this resource. 🎀
base_path = '/os-keypairs' — the base part of the URI for this resource. 🦋
allow_create = True — create is allowed for this resource. 💖
allow_fetch = True — get is allowed for this resource. 🌸
allow_delete = True — delete is allowed for this resource. 🫶
allow_list = True — list is allowed for this resource. 😭
created_at — the date and time when the resource was created. ⭐
is_deleted — a boolean that says whether this keypair is deleted or not. 💀
fingerprint — the short fingerprint associated with the public_key for this keypair. 🔥
id — the id identifying the keypair. 👑
name — a name identifying the keypair. 🌈
private_key — the private key for the keypair. 🙈
public_key — the SSH public key that is paired with the server. 🍓
type — the type of the keypair. 🧚
user_id — the user_id for a keypair. 💜

classmethod existing(connection=None, **kwargs) — create an instance of an existing remote resource. When you create the instance, set the _synchronized parameter of Resource to True to show that it represents the state of an existing server-side resource. That means all attributes passed in **kwargs are considered “clean” — so an immediate update() call would not generate a body of attributes to be modified on the server. No cap. ✨

Parameters

kwargs (dict) — each of the named arguments will be set as attributes on the resulting Resource object. 💖

openstack.compute.v2.limits

The Limits Class ✨

The Limits class inherits from Resource. 🦋

class openstack.compute.v2.limits.Limits(_synchronized=False, connection=None, **attrs)

This is the base resource. 💅

Parameters

_synchronized — not intended to be used directly, bestie. See new() and existing(). 🎀
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None. 🌸
base_path = '/limits' — the base part of the URI for this resource. ⭐
resource_key = 'limits' — the singular key name for this resource. 🔥
allow_fetch = True — get is allowed for this resource. 🫶
absolute — an absolute limits object. 👑
rate — rate-limit compute resources. This is only populated when using the legacy v2 API, which was removed in Nova 14.0.0 (Newton). In v2.1 it will always be an empty list. 💀

fetch(session, requires_id=False, base_path=None, error_message=None, skip_cache=False, **params) — get the Limits resource.

Parameters
- session (Adapter) — the session to use for making this request. 🌈
Returns — a Limits instance. 🍓
Return type — Limits. 🧚

The AbsoluteLimits Class 💜

The AbsoluteLimits class inherits from Resource. 🦋

class openstack.compute.v2.limits.AbsoluteLimits(_synchronized=False, connection=None, **attrs)

This is the base resource. 💅

Parameters

_synchronized — not intended to be used directly. See new() and existing(). 🎀
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None. 🌸
image_meta — the number of key-value pairs that can be set as image metadata. ✨
personality — the maximum number of personality contents that can be supplied. 💖
personality_size — the maximum size, in bytes, of a personality. 🎀
security_group_rules — the maximum amount of security group rules allowed. 🦋
security_groups — the maximum amount of security groups allowed. 🌸
security_groups_used — the amount of security groups currently in use. 🫶
server_meta — the number of key-value pairs that can be set as server metadata. 😭
total_cores — the maximum amount of cores. ⭐
total_cores_used — the amount of cores currently in use. 🔥
floating_ips — the maximum amount of floating IPs. 👑
floating_ips_used — the amount of floating IPs currently in use. 🌈
instances — the maximum amount of instances. 🍓
instances_used — the amount of instances currently in use. 🧚
keypairs — the maximum amount of keypairs. 💜
total_ram — the maximum RAM size in megabytes. 💅
total_ram_used — the RAM size in megabytes currently in use. ✨
server_groups — the maximum amount of server groups. 💖
server_groups_used — the amount of server groups currently in use. 🎀
server_group_members — the maximum number of members in a server group. 🦋

The RateLimit Class 🌸

The RateLimit class inherits from Resource. 🫶

class openstack.compute.v2.limits.RateLimit(_synchronized=False, connection=None, **attrs)

This is the base resource. 💅

Parameters

_synchronized — not intended to be used directly. See new() and existing(). 🎀
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None. 🌸
next_available — rate limits next availabe time. 😭
remaining — integer for rate limits remaining. ⭐
unit — unit of measurement for the value parameter. 🔥
value — integer number of requests which can be made. 👑
verb — an HTTP verb (POST, PUT, etc.). 🌈

openstack.compute.v2.migration

The Migration Class 🍓

The Migration class inherits from Resource. 🧚

class openstack.compute.v2.migration.Migration(_synchronized=False, connection=None, **attrs)

This is the base resource. 💅

Parameters

_synchronized — not intended to be used directly. See new() and existing(). 🎀
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None. 🌸
resources_key = 'migrations' — the plural key name for this resource. 💜
base_path = '/os-migrations' — the base part of the URI for this resource. ✨
allow_list = True — list is allowed for this resource. 💖
created_at — the date and time when the resource was created. 🎀
dest_compute — the target compute of the migration. 🦋
dest_host — the target host of the migration. 🌸
dest_node — the target node of the migration. 🫶
migration_type — the type of the migration. One of 'migration', 'resize', 'live-migration' or 'evacuation'. 😭
new_flavor_id — the ID of the old flavor. This value corresponds to the ID of the flavor in the database. This will be the same as new_flavor_id except for resize operations. ⭐
old_flavor_id — the ID of the old flavor. This value corresponds to the ID of the flavor in the database. 🔥
project_id — the ID of the project that initiated the server migration (since microversion 2.80). 👑
server_id — the UUID of the server. 🌈
source_compute — the source compute of the migration. 🍓
source_node — the source node of the migration. 🧚
status — the current status of the migration. 💜
updated_at — the date and time when the resource was last updated. 💅
user_id — the ID of the user that initiated the server migration (since microversion 2.80). ✨
uuid — the UUID of the migration (since microversion 2.59). 💖

openstack.compute.v2.quota_set

The QuotaSet Class 🎀

The QuotaSet class inherits from Resource. 🦋

class openstack.compute.v2.quota_set.QuotaSet(_synchronized=False, connection=None, **attrs)

This is the base resource. 💅

Parameters

_synchronized — bestie, this one is not meant to be used directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing> for the actual move. 🫶
connection — reference to the Connection being used. Defaults to None so Resource objects can exist without an active Connection, like in unit tests. Any use of self._connection in Resource code should protect itself with a check for None. no cap.
cores — Properties: the number of allowed server cores for each tenant.
fixed_ips — the number of allowed fixed IP addresses for each tenant. Must be equal to or greater than the number of allowed servers.
floating_ips — the number of allowed floating IP addresses for each tenant.
force — okay this is the pushy one: you can force the update even if the quota has already been used and the reserved quota exceeds the new quota. 💅
injected_file_content_bytes — the number of allowed bytes of content for each injected file.
injected_file_path_bytes — the number of allowed bytes for each injected file path.
injected_files — the number of allowed injected files for each tenant.
instances — the number of allowed servers for each tenant.
key_pairs — the number of allowed key pairs for each user.
metadata_items — the number of allowed metadata items for each server.
networks — the number of private networks that can be created per project.
ram — the amount of allowed server RAM, in MiB, for each tenant.
security_group_rules — the number of allowed rules for each security group.
security_groups — the number of allowed security groups for each tenant.
server_groups — the number of allowed server groups for each tenant.
server_group_members — the number of allowed members for each server group.

✨ openstack.compute.v2.server ✨

🖥️ The Server Class 🖥️

The Server class inherits from Resource <#openstack.resource.Resource>. It's giving main-character resource energy, honestly.

class openstack.compute.v2.server.Server(_synchronized=False, connection=None, **attrs)

The base resource. Literally the blueprint era.

💫 Parameters 💫

_synchronized — this is not intended to be used directly, bestie. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
connection — reference to the Connection being used. Defaults to None to let Resource objects hang out without an active Connection, like in unit tests. Use of self._connection in Resource code should protect itself with a check for None.

Okay and the class is lowkey carrying these:

resource_key = 'server' — singular form of key for resource.
resources_key = 'servers' — plural form of key for resource.
base_path = '/servers' — the base part of the URI for this resource.
allow_create = True — allow create operation for this resource.
allow_fetch = True — allow get operation for this resource.
allow_commit = True — allow update operation for this resource.
allow_delete = True — allow delete operation for this resource.
allow_list = True — allow list operation for this resource.

Now the actual data fields this server is serving, no cap:

links — a list of dictionaries holding links relevant to this server.
addresses — a dictionary of addresses this server can be accessed through. The dictionary contains keys such as private and public, each containing a list of dictionaries for addresses of that type. The addresses are contained in a dictionary with keys addr and version, which is either 4 or 6 depending on the protocol of the IP address. Type: dict
admin_password — when a server is first created, it provides the administrator password.
attached_volumes — a list of an attached volumes. Each item in the list contains at least an "id" key to identify the specific volumes.
availability_zone — the name of the availability zone this server is a part of.
block_device_mapping — enables fine grained control of the block device mapping for an instance. This is typically used for booting servers from volumes.
config_drive — indicates whether or not a config drive was used for this server.
compute_host — the name of the compute host on which this instance is running. Appears in the response for administrative users only.
created_at — timestamp of when the server was created.
description — the description of the server. Before microversion 2.19 this was set to the server name.
disk_config — the disk configuration. Either AUTO or MANUAL.
flavor_id — the flavor reference, as a ID or full URL, for the flavor to use for this server.
flavor — the flavor property as returned from server.
has_config_drive — indicates whether a configuration drive enables metadata injection. Not all cloud providers enable this feature.
host_id — an ID representing the host of this server.
fault — a fault object. Only available when the server status is ERROR or DELETED and a fault occurred.
host — the host to boot the server on.
host_status — the host status.
hostname — the hostname set on the instance when it is booted. By default, it appears in the response for administrative users only.
hypervisor_hostname — the hypervisor host name. Appears in the response for administrative users only.
image_id — the image reference, as a ID or full URL, for the image to use for this server.
image — the image property as returned from server.
instance_name — the instance name. The Compute API generates the instance name from the instance name template. Appears in the response for administrative users only.
interface_ip — the address to use to connect to this server from the current calling context. This will be set to public_ipv6 if the calling host has routable ipv6 addresses, and to private_ipv4 if the Connection was created with private=True. Otherwise it will be set to public_ipv4.
kernel_id — the UUID of the kernel image when using an AMI. Will be null if not. By default, it appears in the response for administrative users only.
key_name — the name of an associated keypair
launch_index — when servers are launched via multiple create, this is the sequence in which the servers were launched. By default, it appears in the response for administrative users only.
launched_at — the timestamp when the server was launched.
locked_reason — the reason the server was locked, if any.
max_count — the maximum number of servers to create.
min_count — the minimum number of servers to create.
networks — a networks object. Required parameter when there are multiple networks defined for the tenant. When you do not specify the networks parameter, the server attaches to the only network created for the current tenant.
personality — personality files. This should be a list of dicts with each dict containing a file name ('name') and a base64-encoded file contents ('contents')
pinned_availability_zone — the availability zone requested during server creation OR pinned availability zone, which is configured using default_schedule_zone config option.
power_state — the power state of this server.
progress — while the server is building, this value represents the percentage of completion. Once it is completed, it will be 100. Type: int
project_id — the ID of the project this server is associated with.
private_v4 — the private IPv4 address of this server
private_v6 — the private IPv6 address of this server
public_v4 — the public IPv4 address of this server
public_v6 — the public IPv6 address of this server
ramdisk_id — the UUID of the ramdisk image when using an AMI. Will be null if not. By default, it appears in the response for administrative users only.
reservation_id — the reservation id for the server. This is an id that can be useful in tracking groups of servers created with multiple create, that will all have the same reservation_id. By default, it appears in the response for administrative users only.
root_device_name — the root device name for the instance. By default, it appears in the response for administrative users only.
scheduler_hints — the dictionary of data to send to the scheduler.
security_groups — a list of applicable security groups. Each group contains keys for description, name, id, and rules.
server_groups — the UUIDs of the server groups to which the server belongs. Currently this can contain at most one entry.
status — what state your server is in rn. Valid values are: ACTIVE, BUILDING, DELETED, ERROR, HARD_REBOOT, PASSWORD, PAUSED, REBOOT, REBUILD, RESCUED, RESIZED, REVERT_RESIZE, SHUTOFF, SOFT_DELETED, STOPPED, SUSPENDED, UNKNOWN, or VERIFY_RESIZE. yes all of those, it's a whole mood board 😭
task_state — the task state of this server.
terminated_at — the timestamp of when the server was terminated (if it has been, rip 🪦).
trusted_image_certificates — a list of trusted certificate IDs that were used during image signature verification to verify the signing certificate. cute little chain of trust 💖
updated_at — timestamp of when this server was last updated.
user_data — configuration info or scripts to use upon launch. must be Base64 encoded, no cap, that's the rule.
user_id — the ID of the owners of this server.
vm_state — the VM state of this server.

`change_password(session, password, *, microversion=None)`

Change the administrator password to whatever password you pass in. glow-up for the admin account 🔑

Parameters

session — the session to use for making this request.
password — the new password.

Returns None

`get_password(session, *, microversion=None)`

Get the encrypted administrator password.

Parameters

session — the session to use for making this request.

Returns The encrypted administrator password.

`clear_password(session, *, microversion=None)`

Clear the administrator password.

Lowkey important nuance: this removes the password from the database. It does not actually change the server password. Like, it's giving "deleted the receipt but the subscription is still active" 💀

Parameters

session — the session to use for making this request.

Returns None

`reboot(session, reboot_type)`

Reboot the server, where reboot_type might be 'SOFT' or 'HARD'. choose your fighter ✨

Parameters

session — the session to use for making this request.
reboot_type — the type of reboot. One of: SOFT, HARD.

Returns None

`force_delete(session)`

Force delete the server. no soft launch, we're just gone 🫶

Parameters

session — the session to use for making this request.

Returns None

`rebuild(session, image, name=Unset.UNSET, admin_password=Unset.UNSET, preserve_ephemeral=Unset.UNSET, access_ipv4=Unset.UNSET, access_ipv6=Unset.UNSET, metadata=Unset.UNSET, user_data=Unset.UNSET, key_name=Unset.UNSET, description=Unset.UNSET, trusted_image_certificates=Unset.UNSET, hostname=Unset.UNSET)`

Rebuild the server with the given arguments. full main-character transformation arc 🦋

Parameters

session — the session to use for making this request.
image — the image to rebuild to. Either an ID or a Image <#openstack.image.v2.image.Image> instance.
name — a name to set on the rebuilt server. (Optional)
admin_password — an admin password to set on the rebuilt server. (Optional)
preserve_ephemeral — whether to preserve the ephemeral drive during the rebuild. (Optional)
access_ipv4 — an IPv4 address that will be used to access the rebuilt server. (Optional)
access_ipv6 — an IPv6 address that will be used to access the rebuilt server. (Optional)
metadata — metadata to set on the updated server. (Optional)
user_data — user data to set on the updated server. (Optional)
key_name — a key name to set on the updated server. (Optional)
description — the description to set on the updated server. (Optional) (requires API microversion 2.19)
trusted_image_certificates — the trusted image certificates to set on the updated server. (Optional) (requires API microversion 2.78)
hostname — the hostname to set on the updated server. (Optional) (requires API microversion 2.90)

Returns The updated server.

`resize(session, flavor)`

Resize the server to a flavor reference. it's giving "new year new me" but for compute 🧚

Parameters

session — the session to use for making this request.
flavor — the server to resize to.

Returns None

`confirm_resize(session)`

Confirm the resize of the server. committing to the bit ✨

Parameters

session — the session to use for making this request.

Returns None

`revert_resize(session)`

Revert the resize of the server. actually no, take me back 😭

Parameters

session — the session to use for making this request.

Returns None

`create_image(session, name, metadata=None)`

Create an image from the server. snapshot slay 📸

Parameters

session — the session to use for making this request.
name — the name to use for the created image.
metadata — metadata to set on the created image. (Optional)

Returns image uuid

`add_security_group(session, security_group_name)`

Add a security group to the server.

Parameters

session — the session to use for making this request.
security_group_name — the security group to add to the server.

Returns None

`remove_security_group(session, security_group_name)`

Remove a security group from the server.

Parameters

session — the session to use for making this request.
security_group_name — the security group to remove from the server.

Returns None

`reset_state(session, state)`

Reset the server state.

Heads up bestie: this is admin-only by default. don't try it on a regular account, it's not gonna go how you think 💀

Parameters

session — the session to use for making this request.
state — the state to set on the server.

Returns None

`add_fixed_ip(session, network_id)`

Add a fixed IP to the server.

This is effectively an alias for adding a network.

Parameters

session — the session to use for making this request.
network_id — the network to connect the server to.

Returns None

`remove_fixed_ip(session, address)`

Remove a fixed IP from the server.

This is effectively an alias for removing a port from the server.

Parameters

session — the session to use for making this request.
network_id — the address to remove from the server.

Returns None

ok so yes, the parameter in the docs is called network_id even though the signature says address — that's literally how it's written, we don't make the rules, we just report them 🙈

`add_floating_ip(session, address, fixed_address=None)`

Add a floating IP to the server.

Parameters

session — the session to use for making this request.
address — the floating IP address to associate with the server.
fixed_address — a fixed IP address with which to associated the floating IP. (Optional)

Returns None

`remove_floating_ip(session, address)`

Remove a floating IP from the server.

Parameters

session — the session to use for making this request.
address — the floating IP address to disassociate from the server.

Returns None

`backup(session, name, backup_type, rotation)`

Create a backup of the server. be responsible, bestie 🎀

Parameters

session — the session to use for making this request.
name — the name to use for the backup image.
backup_type — the type of backup. the value and meaning of this atribute is user-defined and can be used to separate backups of different types. for example, this could be used to distinguish between daily and weekly backups.
rotation — the number of backups to retain. all images older than the rotation'th image will be deleted. yes, deleted deleted 🔥

Returns image uuid

`pause(session)`

Pause the server. brb, frozen in time ⏸️

Parameters

session — the session to use for making this request.

Returns: None

🌸 `unpause(session)` 🌸

Unpause the server. Like waking it back up, bestie.

Parameters:

session — the session to use for making this request.

Returns: None

🦋 `suspend(session)` 🦋

Suspend the server.

Parameters:

session — the session to use for making this request.

Returns: None

✨ `resume(session)` ✨

Resume the server.

Parameters:

session — the session to use for making this request.

Returns: None

💅 `lock(session, locked_reason=None)` 💅

Lock the server.

Parameters:

session — the session to use for making this request.
locked_reason — the reason for locking the server.

Returns: None

🔐 `unlock(session)` 🔐

Unlock the server.

Parameters:

session — the session to use for making this request.

Returns: None

🚑 `rescue(session, admin_pass=None, image=None)` 🚑

Rescue the server.

This is admin-only by default. 👑

Parameters:

session — the session to use for making this request.
admin_pass — a new admin password to set on the rescued server. (Optional)
image — the image to use when rescuing the server. If not provided, the server will use the existing image. (Optional)

Returns: None

🩹 `unrescue(session)` 🩹

Unrescue the server.

This is admin-only by default. 👑

Parameters:

session — the session to use for making this request.

Returns: None

🚨 `evacuate(session, host=None, admin_pass=None, force=None, on_shared_storage=None)` 🚨

Evacuate the server.

Parameters:

session — the session to use for making this request.
host — the host to evacuate the instance to. (Optional)
admin_pass — the admin password to set on the evacuated instance. (Optional)
force — whether to force evacuation.
on_shared_storage — whether the host is using shared storage. (Optional) (Only supported before microversion 2.14)

Returns: None

🟢 `start(session)` 🟢

Start the server.

Parameters:

session — the session to use for making this request.

Returns: None

🔴 `stop(session)` 🔴

Stop the server.

Parameters:

session — the session to use for making this request.

Returns: None

🎀 `restore(session)` 🎀

Restore the server.

This is only supported if the server is soft-deleted. This is cloud-specific.

Parameters:

session — the session to use for making this request.

Returns: None

📦 `shelve(session)` 📦

Shelve the server.

Parameters:

session — the session to use for making this request.

Returns: None

🧊 `shelve_offload(session)` 🧊

Shelve-offload the server.

Parameters:

session — the session to use for making this request.

Returns: None

🌤️ `unshelve(session, availability_zone=Unset.UNSET, host=None)` 🌤️

Unshelve the server.

Parameters:

session — the session to use for making this request.
availability_zone — if specified the instance will be unshelved to the availability_zone. If None is passed the instance defined availability_zone is unpin and the instance will be scheduled to any availability_zone (free scheduling). If not specified the instance will be unshelved to either its defined availability_zone or any availability_zone (free scheduling).
host — if specified the host to unshelve the instance.

🛫 `migrate(session, *, host=None)` 🛫

Migrate the server.

Parameters:

session — the session to use for making this request.
host — the host to migrate the server to. (Optional)

Returns: None

💥 `trigger_crash_dump(session)` 💥

Trigger a crash dump for the server.

Parameters:

session — the session to use for making this request.

Returns: None

🖥️ `get_console_output(session, length=None)` 🖥️

Get console output for the server.

Parameters:

session — the session to use for making this request.
length — the max length of the console output to return. (Optional)

Returns: the console output.

🌈 `get_console_url(session, console_type)` 🌈

Get the console URL for the server.

Parameters:

session — the session to use for making this request.
console_type — the type of console to return. This is cloud-specific. One of: novnc, xvpvnc, spice-html5, spice-direct (after Nova microversion 2.99), rdp-html5, or serial.

Returns: the console URL.

🛰️ `live_migrate(session, host, force, block_migration, disk_over_commit=False)` 🛰️

Live migrate the server.

Parameters:

session — the session to use for making this request.
host — the host to live migrate the server to. (Optional)
force — whether to force the migration. (Optional)
block_migration — whether to do block migration. One of: True, False, 'auto'. (Optional)
disk_over_commit — whether to allow disk over-commit on the destination host. (Optional)

Returns: None

🕸️ `fetch_topology(session)` 🕸️

Fetch the topology information for the server.

Parameters:

session — the session to use for making this request.

Returns: None

🛡️ `fetch_security_groups(session)` 🛡️

Fetch security groups of the server.

Parameters:

session — the session to use for making this request.

Returns: updated Server instance.

🦋 `openstack.compute.v2.server_action` 🦋

💖 The ServerAction Class 💖

The ServerAction class inherits from Resource.

class openstack.compute.v2.server_action.ServerAction(_synchronized=False,
connection=None, **attrs)

The base resource

Parameters:

_synchronized — this is not intended to be used directly. See new() and existing().
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.
resource_key = 'instanceAction' — singular form of key for resource.
resources_key = 'instanceActions' — plural form of key for resource.
base_path = '/servers/%(server_id)s/os-instance-actions' — the base part of the URI for this resource.
allow_fetch = True — allow get operation for this resource.
allow_list = True — allow list operation for this resource.
server_id — the ID of the server that this action relates to.
action — the name of the action.
request_id — the ID of the request that this action related to.
user_id — the ID of the user which initiated the server action.
project_id — the ID of the project that this server belongs to.
message — the related error message for when an action fails.
events — events.

🧚 The ServerActionEvent Class 🧚

The ServerActionEvent class inherits from Resource.

class openstack.compute.v2.server_action.ServerActionEvent(_synchronized=False,
connection=None, **attrs)

The base resource

Parameters:

_synchronized — nope, don't touch this one directly bestie, it's not for you 😌. See new() and existing() instead.
connection — the reference to the Connection being used. Defaults to None so Resource objects can vibe on their own without an active Connection (unit tests, looking at you 💅). Any self._connection usage in Resource code better protect itself with a None check, fr fr.

event — the name of the event ✨

start_time — the date and time when the event was started. The date and time stamp format is ISO 8601 🕐

finish_time — the date and time when the event finished. The date and time stamp format is ISO 8601 🕐

result — the result of the event

traceback — the traceback stack if an error occurred in this event 😭. This is only visible to cloud admins by default.

host — the name of the host on which the event occurred. This is only visible to cloud admins by default.

host_id — an obfuscated hashed host ID string, or the empty string if there's no host for the event. It's a hashed value so it will not actually look like a hostname, and it's hashed with data from the project_id — so the same physical host seen by two different project_ids will come out different 👀. Super useful when, within the same project, you need to figure out whether two events happened on the same physical host or on different ones.

details — details of the event. May be unset.

🌸 `openstack.compute.v2.server_diagnostics`

The ServerDiagnostics Class

The ServerDiagnostics class inherits from Resource <#openstack.resource.Resource>, bestie 🫶

class openstack.compute.v2.server_diagnostics.ServerDiagnostics(_synchronized=False, connection=None, **attrs)

The base resource

Parameters

_synchronized — this is not intended to be used directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.

resource_key = 'diagnostics' — singular form of key for resource.

base_path = '/servers/%(server_id)s/diagnostics' — the base part of the URI for this resource.

allow_fetch = True — allow get operation for this resource.

requires_id = False — do calls for this resource require an ID.

has_config_drive — indicates whether or not a config drive was used for this server.

state — the current state of the VM.

driver — the driver on which the VM is running.

hypervisor — the hypervisor on which the VM is running.

hypervisor_os — the hypervisor OS.

uptime — the amount of time in seconds that the VM has been running.

num_cpus — the number of vCPUs.

num_disks — the number of disks.

num_nics — the number of vNICs.

memory_details — the dictionary with information about VM memory usage.

cpu_details — the list of dictionaries with detailed information about VM CPUs.

disk_details — the list of dictionaries with detailed information about VM disks.

nic_details — the list of dictionaries with detailed information about VM NICs.

server_id — the ID for the server 🖥️

🦋 `openstack.compute.v2.server_external_event`

The ServerExternalEvent Class

The ServerExternalEvent class inherits from Resource <#openstack.resource.Resource> 💜

class openstack.compute.v2.server_external_event.ServerExternalEvent(_synchronized=False, connection=None, **attrs)

The base resource

Parameters

_synchronized — this is not intended to be used directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>`.
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.

resource_key = None — singular form of key for resource.

resources_key = 'events' — plural form of key for resource.

base_path = '/os-server-external-events' — the base part of the URI for this resource.

requires_id = False — do calls for this resource require an ID.

create_opts — class-level configuration for the create operation. Subclasses can override this to set per-resource defaults without overriding create():

CreateOpts(request_key=<Unset.UNSET: 'UNSET'>, response_key=<Unset.UNSET: 'UNSET'>, method='POST', requires_id=False, response_has_body=True)

allow_create = True — allow create operation for this resource.

allow_fetch = False — allow get operation for this resource.

allow_delete = False — allow delete operation for this resource.

allow_list = False — allow list operation for this resource.

allow_commit = False — allow update operation for this resource.

name — the name of this event ✨

code — the result code (set in the response)

🎀 `openstack.compute.v2.server_group`

The ServerGroup Class

The ServerGroup class inherits from Resource <#openstack.resource.Resource> 🌸

class openstack.compute.v2.server_group.ServerGroup(_synchronized=False, connection=None, **attrs)

The base resource

Parameters

_synchronized — this is not intended to be used directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>`.
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.

resource_key = 'server_group' — singular form of key for resource.

resources_key = 'server_groups' — plural form of key for resource.

base_path = '/os-server-groups' — the base part of the URI for this resource.

allow_create = True — allow create operation for this resource.

allow_fetch = True — allow get operation for this resource.

allow_delete = True — allow delete operation for this resource.

allow_list = True — allow list operation for this resource.

name — a name identifying the server group 🏷️

policies — the list of policies supported by the server group (till 2.63)

policy — the policy field represents the name of the policy (from 2.64)

member_ids — the list of members in the server group 👯

metadata — the metadata associated with the server group. This is always empty and only used for preserving compatibility. (so yeah, it's giving decorative 💀)

project_id — the project ID who owns the server group.

rules — the rules field, which is a dict, can be applied to the policy. Currently, only the max_server_per_host rule is supported for the anti-affinity policy. The max_server_per_host rule allows specifying how many members of the anti-affinity group can reside on the same compute host. If not specified, only one member from the same anti-affinity group can reside on a given host.

user_id — the user ID who owns the server group

💅 `openstack.compute.v2.server_interface`

The ServerInterface Class

The ServerInterface class inherits from Resource <#openstack.resource.Resource> 🦋

class openstack.compute.v2.server_interface.ServerInterface(_synchronized=False, connection=None, **attrs)

The base resource

Parameters

_synchronized — this is not intended to be used directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>`.
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.

resource_key = 'interfaceAttachment' — singular form of key for resource.

resources_key = 'interfaceAttachments' — plural form of key for resource.

base_path = '/servers/%(server_id)s/os-interface' — the base part of the URI for this resource.

allow_create = True — allow create operation for this resource.

allow_fetch = True — allow get operation for this resource.

allow_commit = False — allow update operation for this resource.

allow_delete = True — allow delete operation for this resource.

allow_list = True — allow list operation for this resource.

fixed_ips — fixed IP addresses with subnet IDs.

mac_addr — the MAC address.

net_id — the network ID 🌐

port_id — the ID of the port you're making an interface for, bestie 💖
port_state — the port state. that's the whole vibe.
server_id — the ID for the server 👑
tag — tags for the virtual interfaces 🏷️

🌈 openstack.compute.v2.server_ip 🌈

The ServerIP Class ✨

okay so the ServerIP class inherits from Resource <#openstack.resource.Resource> — it's giving "chip off the old block," iconic behavior 💅

class openstack.compute.v2.server_ip.ServerIP(_synchronized=False,
connection=None, **attrs)

the base resource 🫶

Parameters

_synchronized — ngl this is not meant to be used directly, bestie. see new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing> instead 💀
connection — a reference to the Connection being used. defaults to None so Resource objects can be used without an active Connection, like in unit tests. and like, if you're using self._connection inside Resource code, protect yourself with a check for None — periodt 🙈
resources_key = 'addresses' — the plural form of the key for the resource 🎀
base_path = '/servers/%(server_id)s/ips' — the base part of the URI for this resource 🌸
allow_list = True — allow the list operation for this resource, slay ✨
address — the IP address. the format of the address depends on version 👀
network_label — the network label, like public or private 🦋
server_id — the ID for the server 👑

classmethod list(session, paginated=False, base_path=None,
allow_unknown_params=False, *, microversion=None, headers=None,
max_items=None, server_id=None, network_label=None, **params)

this method is a generator which yields resource objects 🔥 this resource object list generator handles pagination and takes query params for response filtering. lowkey does it all.

Parameters

session — the session to use for making this request 💜
paginated — True if a GET to this resource returns a paginated series of responses, or False if a GET returns only one page of data. when paginated is False, only one page of data gets returned regardless of the API's support of pagination 📄
base_path — the base part of the URI for listing resources, if it's different from base_path <#openstack.resource.Resource.base_path> 🛤️
allow_unknown_params — True to accept, but discard, unknown query parameters. this lets you get a list of 'filters' and pass everything known to the server. False will result in a validation exception when unknown query parameters are passed ⚠️
microversion — the API version to override the negotiated one 🔄
headers — additional headers to inject into the HTTP request 📬
max_items — the maximum number of items to return. typically this must be used with paginated=True 🍓
params — these keyword arguments get passed through the _transpose() method to find if any of them match expected query parameters to be sent in the params argument to get(). they're additionally checked against the base_path <#openstack.resource.Resource.base_path> format string to see if any path fragments need to be filled in by the contents of this argument. parameters supported as filters by the server side are passed in the API call, and the remaining parameters are applied as filters to the retrieved results 🧚

Returns — a generator of Resource objects 💫

Raises MethodNotSupported <#openstack.exceptions.MethodNotSupported> if Resource.allow_list is not set to True 😭

Raises InvalidResourceQuery <#openstack.exceptions.InvalidResourceQuery> if the query contains invalid params 🚨

💅 openstack.compute.v2.server_migration 💅

The ServerMigration Class 💀

the ServerMigration class inherits from Resource <#openstack.resource.Resource> — main character energy fr fr 👑

class
openstack.compute.v2.server_migration.ServerMigration(_synchronized=False,
connection=None, **attrs)

the base resource 🫶

Parameters

_synchronized — not intended to be used directly, bestie. see new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing> 🙈
connection — a reference to the Connection being used. defaults to None so Resource objects can be used without an active Connection, such as in unit tests. use of self._connection in Resource code should protect itself with a check for None 💜
resource_key = 'migration' — the singular form of the key for the resource 🎀
resources_key = 'migrations' — the plural form of the key for the resource ✨
base_path = '/servers/%(server_id)s/migrations' — the base part of the URI for this resource 🛤️
allow_fetch = True — allow the get operation for this resource 👀
allow_list = True — allow the list operation for this resource 📋
allow_delete = True — allow the delete operation for this resource 🗑️
server_id — the ID for the server, from the URI of the resource 🔗
created_at — the date and time when the resource was created ⏰
dest_host — the target host of the migration 🖥️
dest_compute — the target compute of the migration ⚙️
dest_node — the target node of the migration 📍
disk_processed_bytes — the amount of disk, in bytes, that has been processed during the migration 💾
disk_remaining_bytes — the amount of disk, in bytes, that still needs to be migrated 💾
disk_total_bytes — the total amount of disk, in bytes, that needs to be migrated 💾
memory_processed_bytes — the amount of memory, in bytes, that has been processed during the migration 🧠
memory_remaining_bytes — the amount of memory, in bytes, that still needs to be migrated 🧠
memory_total_bytes — the total amount of memory, in bytes, that needs to be migrated 🧠
project_id — the ID of the project that initiated the server migration (since microversion 2.80) 🏷️
server_uuid — the UUID of the server, from the response body 🔖
source_compute — the source compute of the migration ⚙️
source_node — the source node of the migration 📍
status — the current status of the migration 📊
updated_at — the date and time when the resource was last updated ⏰
user_id — the ID of the user that initiated the server migration (since microversion 2.80) 🙋
uuid — the UUID of the migration (since microversion 2.59) 🔖
force_complete(session) — force an on-going live migration to complete 🏁

🦋 openstack.compute.v2.server_remote_console 🦋

The ServerRemoteConsole Class ✨

the ServerRemoteConsole class inherits from Resource <#openstack.resource.Resource> — we love a console glow-up 💅

class
openstack.compute.v2.server_remote_console.ServerRemoteConsole(_synchronized=False,
connection=None, **attrs)

the base resource 🫶

Parameters

_synchronized — this is not intended to be used directly. see new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing> 😌
connection — a reference to the Connection being used. defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. use of self._connection in Resource code should protect itself with a check for None 🫶
resource_key = 'remote_console' — the singular form of the key for the resource 🎀
base_path = '/servers/%(server_id)s/remote-consoles' — the base part of the URI for this resource 🛤️
allow_create = True — allow the create operation for this resource ✅
allow_fetch = False — allow the get operation for this resource ❌
allow_commit = False — allow the update operation for this resource ❌
allow_delete = False — allow the delete operation for this resource ❌
allow_list = False — allow the list operation for this resource ❌
protocol — protocol of the remote console 🔌
type — type of the remote console 🏷️
url — URL used to connect to the console 🔗
server_id — the ID for the server 👑

🌸 openstack.compute.v2.service 🌸

The Service Class 🎀

the Service class inherits from Resource <#openstack.resource.Resource> — serving looks, literally 💁‍♀️

class openstack.compute.v2.service.Service(_synchronized=False,
connection=None, **attrs)

the base resource 🫶

Parameters

_synchronized — nope, not intended to be used directly. see new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing> 🙈
connection — a reference to the Connection being used. defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. use of self._connection in Resource code should protect itself with a check for None 💜

okay so, we're jumping back into the Service attribute list mid-glow-up—no recap, just vibes and facts:

resource_key = 'service' — singular form of the key for this resource. 🎀
resources_key = 'services' — plural form of the key for this resource. ✨
base_path = '/os-services' — the base part of the URI for this resource. 💅
allow_list = True — allow list operation for this resource. 👑
allow_commit = True — allow update operation for this resource. 🔥
allow_delete = True — allow delete operation for this resource. 💀
availability_zone — the availability zone of service. 🌸
binary — binary name of service. 🧚
disabled_reason — disabled reason of service. 🙈
is_forced_down — whether or not this service was forced down manually by an administrator after the service was fenced. 🫶
host — the name of the host where service runs. 💜
name — service name. ⭐
state — state of service. 🌈
status — status of service. 🦋
updated_at — the date and time when the resource was updated. 🎀

🔎 classmethod `find`

classmethod find(session, name_or_id, ignore_missing=True,
                 list_base_path=None, *, microversion=None, all_projects=None,
                 **params)

Finds a resource by its name or id. It's giving search-bar main character energy, no cap.

🧾 Parameters

session — the session to use for making this request.
name_or_id — this resource's identifier, if needed by the request. The default is None.
ignore_missing — when set to False, openstack.exceptions.NotFoundException will be raised when the resource does not exist. When set to True, None will be returned when attempting to find a nonexistent resource.
list_base_path — the base_path to use when you need to list resources.
microversion — API version to override the negotiated one.
params — any additional parameters to be passed into underlying methods, such as to existing() (openstack.resource.Resource.existing) in order to pass on URI parameters.

Returns — the Resource object matching the given name or id, or None if nothing matches.

Raises openstack.exceptions.DuplicateResource if more than one resource is found for this request.

Raises openstack.exceptions.NotFoundException if nothing is found and ignore_missing is False.

💾 `commit(session, prepend_key=False, *args, **kwargs)`

commit(session, prepend_key=False, *args, **kwargs)

Commits the state of the instance to the remote resource. Iconic commit behavior, fr fr.

🧾 Parameters

session — the session to use for making this request.
prepend_key — whether the resource_key (openstack.resource.Resource.resource_key) should be prepended in a resource creation request. Default to True. (Yes, the signature says prepend_key=False and this blurb says “Default to True”—both are straight from the source, bestie. 🫶)
retry_on_conflict — whether to enable retries on HTTP CONFLICT (409). Value of None leaves the Adapter defaults.
base_path — base part of the URI for modifying resources, if different from base_path (openstack.resource.Resource.base_path).
microversion — API version to override the negotiated one.
attrs — attributes to pass when updating the resource. These should correspond to either Body or Header values on the resource.

Returns — this Resource instance.

Raises MethodNotSupported (openstack.exceptions.MethodNotSupported) if Resource.allow_commit is not set to True.

Here are the service action methods—same session energy, different jobs:

set_forced_down(session, host=None, binary=None, forced=False) — updates forced_down information of a service.
force_down(session, host=None, binary=None, forced=False) — updates forced_down information of a service.
enable(session, host, binary) — enables service.
disable(session, host, binary, reason=None) — disables service.

🌸 `openstack.compute.v2.usage` 🌸

💖 The Usage Class 💖

The Usage class inherits from Resource.

class openstack.compute.v2.usage.Usage(_synchronized=False,
                                       connection=None, **attrs)

The base resource. Lowkey the blueprint for everything, periodt.

🧾 Parameters

_synchronized — this is not intended to be used directly. See new() (openstack.resource.Resource.new) and existing() (openstack.resource.Resource.existing).
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.
resource_key = 'tenant_usage' — singular form of the key for this resource. 🎀
resources_key = 'tenant_usages' — plural form of the key for this resource. ✨
base_path = '/os-simple-tenant-usage' — the base part of the URI for this resource. 💅
allow_create = False — allow create operation for this resource. 🙈
allow_fetch = True — allow get operation for this resource. 🔥
allow_delete = False — allow delete operation for this resource. 💀
allow_list = True — allow list operation for this resource. 👑
allow_commit = False — allow update operation for this resource. 🫶
project_id — the UUID of the project in a multi-tenancy cloud. 🌈
server_usages — a list of the server usage objects. 🦋
total_local_gb_usage — multiplying the server disk size (in GiB) by hours the server exists, and then adding that all together for each server. 🧚
total_vcpus_usage — multiplying the number of virtual CPUs of the server by hours the server exists, and then adding that all together for each server. ⭐
total_memory_mb_usage — multiplying the server memory size (in MiB) by hours the server exists, and then adding that all together for each server. 💜
total_hours — the total duration that servers exist (in hours). 🎀
start — the beginning time to calculate usage statistics on compute and storage resources. 🌸
stop — the ending time to calculate usage statistics on compute and storage resources. ✨

🧚 The ServerUsage Class 🧚

The ServerUsage class inherits from Resource.

class openstack.compute.v2.usage.ServerUsage(_synchronized=False,
                                             connection=None, **attrs)

The base resource. Same template tea, different resource vibes.

🧾 Parameters

_synchronized — this is not intended to be used directly. See new() (openstack.resource.Resource.new) and existing() (openstack.resource.Resource.existing).
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.
resource_key = None — singular form of the key for this resource. 🎀
resources_key = None — plural form of the key for this resource. ✨
allow_create = False — allow create operation for this resource. 🙈
allow_fetch = False — allow get operation for this resource. 💀
allow_delete = False — allow delete operation for this resource. 💀
allow_list = False — allow list operation for this resource. 🫶
allow_commit = False — allow update operation for this resource. 🦋
hours — the duration that the server exists (in hours). ⭐
flavor — the display name of a flavor. 🌈
instance_id — the UUID of the server. 💜
name — the server name. 🎀
project_id — the UUID of the project in a multi-tenancy cloud. 🌸
memory_mb — the memory size of the server (in MiB). 🧚
local_gb — the sum of the root disk size of the server and the ephemeral disk size of it (in GiB). ✨
vcpus — the number of virtual CPUs that the server uses. 🔥
started_at — the date and time when the server was launched. 👑
ended_at — the date and time when the server was deleted. 💅
state — the VM state. 🌈
uptime — the uptime of the server. 🦋

🦋 `openstack.compute.v2.volume_attachment` 🦋

💜 The VolumeAttachment Class 💜

The VolumeAttachment class inherits from Resource.

class
openstack.compute.v2.volume_attachment.VolumeAttachment(_synchronized=False,
                                                        connection=None, **attrs)

The base resource. Attachment era, but make it resourceful.

🧾 Parameters

_synchronized — this is not intended to be used directly. See new() (openstack.resource.Resource.new) and existing() (openstack.resource.Resource.existing).
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.
resource_key = 'volumeAttachment' — singular form of the key for this resource. 🎀
resources_key = 'volumeAttachments' — plural form of the key for this resource. ✨
base_path = '/servers/%(server_id)s/os-volume_attachments' — the base chunk of the URI for this resource, bestie. It's the address bar starter pack ✨
allow_create = True — yup, you can create this one 🫶
allow_fetch = True — and get it too, lowkey essential 💅
allow_commit = True — updates are allowed, slay 💖
allow_delete = True — and yes, you can delete it, no cap
allow_list = True — listing is on the menu too 🌸
server_id — the ID for the server, obviously 💀
device — name of the device, like ,/dev/vdb. That's literally what the original says, comma and all — keeping it exactly as-is 🎀
id — the ID of the attachment, iconic identifier behavior 👑
volume_id — the ID of the attached volume 💜
attachment_id — the UUID of the associated volume attachment in Cinder. That's the Cinder one, not the other one, iykyk 🦋
bdm_id — the ID of the block device mapping record for the attachment ⭐
tag — virtual device tags for the attachment 🎀
delete_on_termination — says whether to delete the volume when the server gets destroyed. Big consequences energy 😭

`openstack.compute.version`

The Version Class ✨

So the Version class inherits from Resource <#openstack.resource.Resource>, bestie. Family tree moment 🌈

class openstack.compute.version.Version(_synchronized=False, connection=None, **attrs)

The base resource — that's the whole vibe 🫶

Parameters

_synchronized — okay so this one is not intended to be used directly, periodt. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing> instead 💅
connection — reference to the Connection being used. It defaults to None so that Resource objects can be used without an active Connection, like in unit tests. And if you're using self._connection inside Resource code, you gotta protect yourself with a check for None 🔥
resource_key = 'version' — the singular form of the key for the resource 🎀
resources_key = 'versions' — and the plural form, the more the merrier ✨
base_path = '/' — the base part of the URI for this resource. Just a slash. Minimalist icon 💅
allow_list = True — listing allowed, we love to see it 🌸

Container Infrastructure Management Resources

It's giving whole new continent of resources, bestie 🦋

`openstack.container_infrastructure_management.v1.cluster`

The Cluster Class 👑

The Cluster class inherits from Resource <#openstack.resource.Resource> too. Nepo baby but make it API 😭

class openstack.container_infrastructure_management.v1.cluster.Cluster(_synchronized=False, connection=None, **attrs)

The base resource — same as before, the foundation of it all 💖

Parameters

_synchronized — again, not intended to be used directly, don't do it 🫶 See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
connection — reference to the Connection being used, defaults to None so Resource objects work without an active Connection, like in unit tests. And use of self._connection in Resource code should protect itself with a check for None, fr fr 💅
resources_key = 'clusters' — plural form of key for resource 🌈
base_path = '/clusters' — the base part of the URI for this resource ⭐
allow_create = True — can create ✨
allow_fetch = True — can get 🎀
allow_commit = True — can update 💜
allow_delete = True — can delete 🦋
allow_list = True — can list 🌸
allow_patch = True — and can patch, fancy 💅
commit_method = 'PATCH' — the method for committing a resource. This must be PATCH if allow_patch is True. That's a hard requirement, not a suggestion, no cap 🔥
api_address — the endpoint URL of the COE API exposed to end-users 👑
cluster_template_id — the UUID of the cluster template 🎀
coe_version — version info of the chosen COE in the bay/cluster, which helps the client pick the right version of the client. Helpful king behavior ⭐
create_timeout — the timeout for cluster creation in minutes. The value expected is a positive integer. If the timeout is reached during the cluster creation process, the operation will be aborted and the cluster status will be set to CREATE_FAILED. Defaults to 60. So yeah… don't sleep on it 😭
created_at — the date and time when the resource was created. The date and time stamp format is ISO 8601:

CCYY-MM-DDThh:mm:ss±hh:mm

For example, 2015-08-27T09:49:58-05:00. The ±hh:mm value, if included, is the time zone as an offset from UTC. ISO girlies rise 🌈

discovery_url — the custom discovery url for node discovery. This is used by the COE to discover the servers that have been created to host the containers. The actual discovery mechanism varies with the COE. In some cases, the service fills in the server info in the discovery service. In other cases, if the discovery_url is not specified, the service will use the public discovery service at https://discovery.etcd.io. In this case, the service will generate a unique url here for each bay and store the info for the servers 🦋
fixed_network — the name or ID of the network to provide connectivity to the internal network for the bay/cluster 💜
fixed_subnet — the fixed subnet to use when allocating network addresses for nodes in bay/cluster 🌸
flavor_id — the flavor name or ID to use when booting the node servers. Defaults to m1.small 🎀
is_floating_ip_enabled — whether to enable using the floating IP of the cloud provider. Some cloud providers use floating IPs while some use public IPs. When set to true, floating IPs will be used. If this value is not provided, the value of floating_ip_enabled provided in the template will be used. Ship it ✨
is_master_lb_enabled — whether to enable the master load balancer. Since multiple masters may exist in a bay/cluster, a Neutron load balancer is created to provide the API endpoint for the bay/cluster and to direct requests to the masters. In some cases, such as when the LBaaS service is not available, this option can be set to false to create a bay/cluster without the load balancer. In this case, one of the masters will serve as the API endpoint. The default is true, i.e. to create the load balancer for the bay. Main character load balancer energy 👑
keypair — the name of the SSH keypair to configure in the bay/cluster servers for SSH access. Users will need the key to be able to ssh to the servers in the bay/cluster. The login name is specific to the bay/cluster driver. For example, with the fedora-atomic image the default login name is fedora 🔑
labels — arbitrary labels. The accepted keys and valid values are defined in the bay/cluster drivers. They're used as a way to pass additional parameters that are specific to a bay/cluster driver 🏷️
master_addresses — a list of floating IPs of all master nodes 💅
master_count — the number of servers that will serve as master for the bay/cluster. Set it to more than 1 master to enable High Availability. If the option master-lb-enabled is specified in the baymodel/cluster template, the master servers will be placed in a load balancer pool. Defaults to 1 🌈
master_flavor_id — the flavor of the master node for this baymodel/cluster template ⭐
name — name of the resource. Just… the name. Simple, iconic 🎀
node_count — the number of servers that will serve as node in the bay/cluster. Defaults to 1 🌸
node_addresses — a list of floating IPs of all servers that serve as nodes 🦋
stack_id — the reference UUID of the orchestration stack from the Heat orchestration service 🔥
status — the current state of the bay/cluster 💜
status_reason — the reason of the bay/cluster's current status. Receipts, basically 🧾
updated_at — the date and time when the resource was updated. The date and time stamp format is ISO 8601:

CCYY-MM-DDThh:mm:ss±hh:mm

For example, 2015-08-27T09:49:58-05:00. The ±hh:mm value, if included, is the time zone as an offset from UTC. If the updated_at date and time stamp is not set, its value is null. It's giving "no update yet" 💀

uuid — the UUID of the cluster ✨
project_id — the project the cluster belongs to 🫶

`resize(session, *, node_count, nodes_to_remove=None)`

Resize the cluster. Glow-up but for infrastructure 💅

resize(session, *, node_count, nodes_to_remove=None)

Parameters

node_count — the number of servers that will serve as node in the bay/cluster. The default is 1 🎀
nodes_to_remove — the server ID list will be removed if downsizing the cluster. Bye bestie 👋

Returns

The UUID of the resized cluster ✨

Raises

NotFoundException <#openstack.exceptions.NotFoundException> if the resource was not found. So like… if it's not there 😭

`upgrade(session, *, cluster_template, max_batch_size=None)`

Upgrade the cluster. Level-up arc 🌈

upgrade(session, *, cluster_template, max_batch_size=None)

Parameters

cluster_template — the UUID of the cluster template 🎀
max_batch_size — the max batch size each time when doing upgrade. The default is 1 💜

Returns

The UUID of the updated cluster ⭐

Raises

NotFoundException <#openstack.exceptions.NotFoundException> if the resource was not found. Same deal, if it's missing it's missing 🙈

🌸 `openstack.container_infrastructure_management.v1.cluster_certificate`

The Cluster Certificate Class — okay so the ClusterCertificate class inherits from Resource <#openstack.resource.Resource>.

class openstack.container_infrastructure_management.v1.cluster_certificate.ClusterCertificate(_synchronized=False, connection=None, **attrs)

The base resource

Parameters

_synchronized — This is not intended to be used directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
connection — Reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.
base_path = '/certificates' — The base part of the URI for this resource.
allow_create = True — Allow create operation for this resource.
allow_list = False — Allow list operation for this resource.
allow_fetch = True — Allow get operation for this resource.
bay_uuid — The UUID of the bay.
cluster_uuid — The UUID of the cluster.
csr — Certificate Signing Request (CSR) for authenticating client key.
pem — CA certificate for the bay/cluster.

🌈 `openstack.container_infrastructure_management.v1.cluster_template`

The Cluster Template Class — the ClusterTemplate class inherits from Resource <#openstack.resource.Resource>.

class openstack.container_infrastructure_management.v1.cluster_template.ClusterTemplate(_synchronized=False, connection=None, **attrs)

The base resource

Parameters

_synchronized — This is not intended to be used directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
connection — Reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.
resources_key = 'clustertemplates' — Plural form of key for resource.
base_path = '/clustertemplates' — The base part of the URI for this resource.
allow_create = True — Allow create operation for this resource.
allow_fetch = True — Allow get operation for this resource.
allow_commit = True — Allow update operation for this resource.
allow_delete = True — Allow delete operation for this resource.
allow_list = True — Allow list operation for this resource.
allow_patch = True — Allow patch operation for this resource.
commit_method = 'PATCH' — Method for committing a resource. This must be PATCH if allow_patch is True.
apiserver_port — The exposed port of COE API server.
cluster_distro — Display the attribute os_distro defined as appropriate metadata in image for the bay/cluster driver.
coe — Specify the Container Orchestration Engine to use. Supported COEs include kubernetes, swarm, mesos.
created_at — The date and time when the resource was created.
docker_storage_driver — The name of a driver to manage the storage for the images and the container's writable layer.
docker_volume_size — The size in GB for the local storage on each server for the Docker daemon to cache the images and host the containers.
dns_nameserver — The DNS nameserver for the servers and containers in the bay/cluster to use.
external_network_id — The name or network ID of a Neutron network to provide connectivity to the external internet for the bay/cluster.
fixed_network — The name or network ID of a Neutron network to provide connectivity to the internal network for the bay/cluster.
fixed_subnet — Fixed subnet that are using to allocate network address for nodes in bay/cluster.
flavor_id — The nova flavor ID or name for booting the node servers.
http_proxy — The IP address for a proxy to use when direct http access from the servers to sites on the external internet is blocked. This may happen in certain countries or enterprises, and the proxy allows the servers and containers to access these sites. The format is a URL including a port number. The default is None.
https_proxy — The IP address for a proxy to use when direct https access from the servers to sites on the external internet is blocked.
image_id — The name or UUID of the base image in Glance to boot the servers for the bay/cluster.
insecure_registry — The URL pointing to user's own private insecure docker registry to deploy and run docker containers.
is_floating_ip_enabled — Whether enable or not using the floating IP of cloud provider.
is_hidden — Indicates whether the ClusterTemplate is hidden or not.
is_master_lb_enabled — this option can be set to false to create a bay/cluster without the load balancer.
is_tls_disabled — Specifying this parameter will disable TLS so that users can access the COE endpoints without a certificate.
is_public — Setting this flag makes the baymodel/cluster template public and accessible by other users.
is_registry_enabled — This option provides an alternative registry based on the Registry V2
keypair_id — The name of the SSH keypair to configure in the bay/cluster servers for ssh access.
labels — Arbitrary labels. The accepted keys and valid values are defined in the bay/cluster drivers. They are used as a way to pass additional parameters that are specific to a bay/cluster driver.
master_flavor_id — The flavor of the master node for this baymodel/cluster template.
network_driver — The name of a network driver for providing the networks for the containers.
no_proxy — When a proxy server is used, some sites should not go through the proxy and should be accessed normally.
server_type — The servers in the bay/cluster can be vm or baremetal.
updated_at — The date and time when the resource was updated.
uuid — The UUID of the cluster template.
volume_driver — The name of a volume driver for managing the persistent storage for the containers.

🦋 `openstack.container_infrastructure_management.v1.service`

The Service Class — the Service class inherits from Resource <#openstack.resource.Resource>.

class openstack.container_infrastructure_management.v1.service.Service(_synchronized=False, connection=None, **attrs)

The base resource

Parameters

_synchronized — This is not intended to be used directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
connection — Reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.
resources_key = 'mservices' — Plural form of key for resource.
base_path = '/mservices' — The base part of the URI for this resource.
allow_list = True — Allow list operation for this resource.
binary — The name of the binary form of the Magnum service.
created_at — The date and time when the resource was created.
disabled_reason — The disable reason of the service, null if the service is enabled or disabled without reason provided.
host — The host for the service.
report_count — The total number of report.
state — The current state of Magnum services.
updated_at — The date and time when the resource was updated.

💾 Database Resources

🍓 `openstack.database.v1.database`

The Database Class — the Database class inherits from Resource <#openstack.resource.Resource>.

class openstack.database.v1.database.Database(_synchronized=False, connection=None, **attrs)

The base resource

Parameters

_synchronized — This is not intended to be used directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
connection — Reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.
resource_key = 'database' — Singular form of key for resource.
resources_key = 'databases' — Plural form of key for resource.
base_path = '/instances/%(instance_id)s/databases' — The base part of the URI for this resource.
allow_create = True — Allow create operation for this resource.
allow_delete = True — Allow delete operation for this resource.
allow_list = True — Allow list operation for this resource.
character_set — the set of symbols and encodings, like the alphabet the database speaks. default is utf8 ✨
collate — the ruleset for comparing characters inside that character set. default is utf8_general_ci
instance_id — the ID of the instance
name — the name of the database

🦋 `openstack.database.v1.flavor`

The Flavor Class 💅

okay so the Flavor class inherits from Resource (iykyk, that's the base of everything around here).

class openstack.database.v1.flavor.Flavor(_synchronized=False, connection=None, **attrs)

The base resource 🫶 that's literally what it says on the tin.

Parameters

_synchronized — not a thing you touch directly, bestie, fr fr. go look at new() and existing() instead.
connection — a reference to the Connection being used. it defaults to None so Resource objects can exist without an active Connection, like in unit tests. if you're using self._connection inside Resource code, guard it with a None check, okay? protect yourself 💖

Attributes:

resource_key = 'flavor' — the singular form of the key for this resource
resources_key = 'flavors' — the plural form of the key for this resource
base_path = '/flavors' — the base part of the URI for this resource
allow_list = True — allow list operation for this resource, yes queen 👑
allow_fetch = True — allow get operation for this resource
links — links associated with the flavor
name — the name of the flavor
ram — the size in MB of RAM the flavor has

🌈 `openstack.database.v1.instance`

The Instance Class 🔥

this one inherits from Resource too, obviously.

class openstack.database.v1.instance.Instance(_synchronized=False, connection=None, **attrs)

The base resource

Parameters

_synchronized — don't use this directly, seriously. see new() and existing().
connection — a reference to the Connection being used. defaults to None so Resource objects can be used without an active Connection (unit tests, hello). if Resource code uses self._connection, it should protect itself with a None check 🙈

Attributes:

resource_key = 'instance' — the singular form of the key for this resource
resources_key = 'instances' — the plural form of the key for this resource
base_path = '/instances' — the base part of the URI for this resource
allow_create = True — allow create operation for this resource
allow_fetch = True — allow get operation for this resource
allow_commit = True — allow update operation for this resource
allow_delete = True — allow delete operation for this resource
allow_list = True — allow list operation for this resource
flavor — the flavor of the instance
links — links associated with the instance
name — the name of the instance
status — the status of the instance
volume — the size of the volume
datastore — a dictionary of datastore details, usually with 'type' and 'version' keys
id — the ID of this instance
region — the region this instance resides in
hostname — the name of the host
created_at — the timestamp of when this instance was created
updated_at — the timestamp of when this instance was updated

Methods, let's gooo:

enable_root_user(session) — enable login for the root user. this operation enables login from any host for the root user and hands the user a generated root password. parameters: session (Adapter) — the session to use for making this request. returns: a dictionary with the keys name and password specifying the login credentials 🔑
is_root_enabled(session) — determine if root is enabled on an instance. specifically, whether root is enabled on this particular instance. parameters: session (Adapter) — the session to use for making this request. returns: True if the root user is enabled for the specified database instance, False otherwise
restart(session) — restart the database instance. returns: None
resize(session, flavor_reference) — resize the database instance. returns: None
resize_volume(session, volume_size) — resize the volume attached to the instance. returns: None

🎀 `openstack.database.v1.user`

The User Class 💜

yep, inherits from Resource again. it's giving family reunion.

class openstack.database.v1.user.User(_synchronized=False, connection=None, **attrs)

The base resource

Parameters

_synchronized — not intended to be used directly. see new() and existing().
connection — a reference to the Connection being used. defaults to None so Resource objects can be used without an active Connection, such as in unit tests. use of self._connection in Resource code should protect itself with a check for None 💖

Attributes:

resource_key = 'user' — the singular form of the key for this resource
resources_key = 'users' — the plural form of the key for this resource
base_path = '/instances/%(instance_id)s/users' — the base part of the URI for this resource (yes, there's a %(instance_id)s in there, it's a template, don't panic)
allow_create = True — allow create operation for this resource
allow_delete = True — allow delete operation for this resource
allow_list = True — allow list operation for this resource
databases — databases the user has access to
name — the name of the user
password — the password of the user

🌸 DNS Resources

`openstack.dns.v2.blacklist`

The Blacklist Class 🖤

the Blacklist class inherits from Resource.

class openstack.dns.v2.blacklist.Blacklist(_synchronized=False, connection=None, **attrs)

DNS Blacklist Resource — iconic.

The base resource

Parameters

_synchronized — this is not intended to be used directly. see new() and existing().
connection — reference to the Connection being used. defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. use of self._connection in Resource code should protect itself with a check for None.

Attributes:

resources_key = 'blacklists' — plural form of key for resource
base_path = '/blacklists' — the base part of the URI for this resource
allow_list = True — allow list operation for this resource
allow_create = True — allow create operation for this resource
allow_fetch = True — allow get operation for this resource
allow_commit = True — allow update operation for this resource
allow_delete = True — allow delete operation for this resource
commit_method = 'PATCH' — the method for committing a resource. this must be PATCH if allow_patch is True 👀
id — properties ID for the resource
pattern — pattern for this blacklist
description — description for this blacklist
created_at — timestamp of when the blacklist was created
updated_at — timestamp of when the blacklist was last updated
links — links to the resource, and the other related resources

`openstack.dns.v2.floating_ip`

The FloatingIP Class 🦋

the DNS class inherits from Resource.

class openstack.dns.v2.floating_ip.FloatingIP(_synchronized=False, connection=None, **attrs)

DNS Floating IP Resource — floating, literally.

The base resource

Parameters

_synchronized — not intended to be used directly. see new() and existing().
connection — reference to the Connection being used. defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. use of self._connection in Resource code should protect itself with a check for None.

Attributes:

resources_key = 'floatingips' — plural form of key for resource
base_path = '/reverse/floatingips' — the base part of the URI for this resource
allow_fetch = True — allow get operation for this resource
allow_commit = True — allow update operation for this resource
allow_list = True — allow list operation for this resource
commit_method = 'PATCH' — method for committing a resource. this must be PATCH if allow_patch is True
action — the properties' current action in progress on the resource
address — the floatingip address for this PTR record
description — description for this PTR record
ptrdname — domain name for this PTR record
status — status of the resource
ttl — time to live for this PTR record ⏳

✨ `openstack.dns.v2.limit` ✨

🌸 The Limit Class 🌸

The Limit class inherits from Resource <#openstack.resource.Resource>.

class openstack.dns.v2.limit.Limit(_synchronized=False, connection=None,
**attrs)

DNS Limit Resource — okay bestie, this one is the base resource. 💅

Parameters:

_synchronized — This is not intended to be used directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
connection — Reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.
resource_key = 'limit' — Singular form of key for resource.
base_path = '/limits' — The base part of the URI for this resource.
allow_list = True — Allow list operation for this resource.
max_page_limit — Properties: The max amount of items allowed per page.
max_recordset_name_length — The max length of a recordset name.
max_recordset_records — The max amount of records contained in a recordset.
max_zone_name_length — The max length of a zone name.
max_zone_records — The max amount of records in a zone.
max_zone_recordsets — The max amount of recordsets per zone.
max_zones — The max amount of zones for this project.
min_ttl — The lowest ttl allowed on this system.

✨ `openstack.dns.v2.quota` ✨

💖 The Quota Class 💖

The Quota class inherits from Resource <#openstack.resource.Resource>.

class openstack.dns.v2.quota.Quota(_synchronized=False, connection=None,
**attrs)

DNS Quota Resource — yep, the base resource again, bestie. 🫶

Parameters:

_synchronized — This is not intended to be used directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
connection — Reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.
base_path = '/quotas' — The base part of the URI for this resource.
allow_fetch = True — Allow get operation for this resource.
allow_commit = True — Allow update operation for this resource.
allow_delete = True — Allow delete operation for this resource.
allow_list = True — Allow list operation for this resource.
commit_method = 'PATCH' — Method for committing a resource. This must be PATCH if allow_patch is True.
project — The ID of the project.
api_export_size — The maximum amount of recordsets allowed in a zone export. Type: int
recordset_records — The maximum amount of records allowed per recordset. Type: int
zone_records — The maximum amount of records allowed per zone. Type: int
zone_recordsets — The maximum amount of recordsets allowed per zone. Type: int
zones — The maximum amount of zones allowed per project. Type: int

🛠️ `fetch(...)` 🛠️

fetch(session, requires_id=True, base_path=None,
error_message=None, skip_cache=False, *,
resource_response_key=None, microversion=None, **params)

Get a remote resource based on this instance.

Parameters:

session — The session to use for making this request.
requires_id — Whether resource ID should be part of the requested URI.
base_path — Base part of the URI for fetching resources, if different from base_path <# openstack.resource.Resource.base_path>.
error_message — An error message to be returned if requested object does not exist.
skip_cache — A boolean indicating whether optional API cache should be skipped for this invocation.
resource_response_key — Overrides the usage of self.resource_key when processing the response body.
microversion — API version to override the negotiated one.
params — Additional parameters that can be consumed.

Returns: This Resource instance.

💀 Raises: MethodNotSupported <#openstack.exceptions.MethodNotSupported> if Resource.allow_fetch is not set to True.

💀 Raises: NotFoundException <#openstack.exceptions.NotFoundException> if the resource was not found.

🌈 `openstack.dns.v2.recordset` 🌈

🦋 The Recordset Class 🦋

The DNS class inherits from Resource <#openstack.resource.Resource>.

class openstack.dns.v2.recordset.Recordset(_synchronized=False,
connection=None, **attrs)

DNS Recordset Resource — the base resource, but make it DNS. ✨

Parameters:

_synchronized — This is not intended to be used directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
connection — Reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.
resources_key = 'recordsets' — Plural form of key for resource.
base_path = '/zones/%(zone_id)s/recordsets' — The base part of the URI for this resource.
allow_create = True — Allow create operation for this resource.
allow_fetch = True — Allow get operation for this resource.
allow_commit = True — Allow update operation for this resource.
allow_delete = True — Allow delete operation for this resource.
allow_list = True — Allow list operation for this resource.
action — Properties: current action in progress on the resource.
created_at — Timestamp when the zone was created.
description — Recordset description.
links — Links contains a self pertaining to this zone or a next pertaining to next page.
name — DNS Name of the recordset.
project_id — ID of the project which the recordset belongs to.
records — DNS record value list.
status — Recordset status Valid values include: PENDING_CREATE, ACTIVE, PENDING_DELETE, ERROR.
ttl — Time to live, default 300, available value 300-2147483647 (seconds).
type — DNS type of the recordset Valid values include A, AAAA, MX, CNAME, TXT, NS, SSHFP, SPF, SRV, PTR.
updated_at — Timestamp when the zone was last updated.
zone_id — The id of the Zone which this recordset belongs to.
zone_name — The name of the Zone which this recordset belongs to.

⭐ `openstack.dns.v2.service_status` ⭐

🎀 The ServiceStatus Class 🎀

The ServiceStatus class inherits from Resource <#openstack.resource.Resource>.

class openstack.dns.v2.service_status.ServiceStatus(_synchronized=False,
connection=None, **attrs)

Designate Service Statuses — the base resource, serving status realness. 👑

Parameters:

_synchronized — This is not intended to be used directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
connection — Reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.
resources_key = 'service_statuses' — Plural form of key for resource.
base_path = '/service_statuses' — The base part of the URI for this resource.
allow_create = False — Allow create operation for this resource.
allow_fetch = True — Allow get operation for this resource.
allow_commit = False — Allow update operation for this resource.
allow_delete = False — Allow delete operation for this resource.
allow_list = True — Allow list operation for this resource.
capabilities — Capabilities for the service.
created_at — Timestamp when the resource was created.
heartbeated_at — Timestamp when the last heartbeat was received.
hostname — Hostname of the host with the service instance Type: str
links — Links contains a self pertaining to this service status or a next pertaining to next page.
service_name — The name of the Designate service instance Type: str
stats — Statistics for the service.
status — The status of the resource Type: enum
updated_at — Timestamp when the resource was last updated.

🧚 `openstack.dns.v2.tld` 🧚

💜 The TLD Class 💜

The DNS class inherits from Resource <#openstack.resource.Resource>.

class openstack.dns.v2.tld.TLD(_synchronized=False, connection=None,
**attrs)

DNS TLD Resource — the base resource, top-level domain edition. 🌈

Parameters:

_synchronized — This is not intended to be used directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.

okay so continuing the tld resource deets, bestie:

connection — Reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.
resources_key = 'tlds' — Plural form of key for resource.
base_path = '/tlds' — The base part of the URI for this resource.
allow_create = True — Allow create operation for this resource.
allow_fetch = True — Allow get operation for this resource.
allow_commit = True — Allow update operation for this resource.
allow_delete = True — Allow delete operation for this resource.
allow_list = True — Allow list operation for this resource.
commit_method = 'PATCH' — Method for committing a resource. This must be PATCH if allow_patch is True.
name — TLD name
description — TLD description
created_at — Timestamp when the tld was created
updated_at — Timestamp when the tld was last updated
links — Links contains a self pertaining to this tld or a next pertaining to next page

🌸 openstack.dns.v2.zone 🌸

The Zone Class 🦋

The DNS class inherits from Resource <#openstack.resource.Resource>.

class openstack.dns.v2.zone.Zone(_synchronized=False, connection=None, **attrs)

DNS ZONE Resource 💅

The base resource

Parameters

_synchronized — This is not intended to be used directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
connection — Reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.
resources_key = 'zones' — Plural form of key for resource.
base_path = '/zones' — The base part of the URI for this resource.
allow_create = True — Allow create operation for this resource.
allow_fetch = True — Allow get operation for this resource.
allow_commit = True — Allow update operation for this resource.
allow_delete = True — Allow delete operation for this resource.
allow_list = True — Allow list operation for this resource.
commit_method = 'PATCH' — Method for committing a resource. This must be PATCH if allow_patch is True.
action — Properties current action in progress on the resource
attributes — Attributes Key:Value pairs of information about this zone, and the pool the user would like to place the zone in. This information can be used by the scheduler to place zones on the correct pool.
created_at — Timestamp when the zone was created
description — Zone description Type: str
email — The administrator email of this zone Type: str
links — Links contains a self pertaining to this zone or a next pertaining to next page
masters — The master list for slaver server to fetch DNS
name — Zone name
pool_id — The pool which manages the zone, assigned by system
project_id — The project id which the zone belongs to
serial — Serial number in the SOA record set in the zone, which identifies the change on the primary DNS server Type: int
status — Zone status Valid values include PENDING_CREATE, ACTIVE, PENDING_DELETE, ERROR
ttl — SOA TTL time, unit is seconds, default 300, TTL range 300-2147483647 Type: int
type — Zone type, Valid values include PRIMARY, SECONDARY Type: str
updated_at — Timestamp when the zone was last updated
is_shared — Whether the zone is shared with other projects Type: bool
delete_shares — If true, delete any existing zone shares along with the zone

🌈 openstack.dns.v2.zone_export 🌈

The ZoneExport Class 🎀

The DNS class inherits from Resource <#openstack.resource.Resource>.

class openstack.dns.v2.zone_export.ZoneExport(_synchronized=False, connection=None, **attrs)

DNS Zone Exports Resource ✨

The base resource

Parameters

_synchronized — This is not intended to be used directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
connection — Reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.
resource_key = '' — Singular form of key for resource.
resources_key = 'exports' — Plural form of key for resource.
base_path = '/zones/tasks/export' — The base part of the URI for this resource.
create_opts — Class-level configuration for the create operation. Subclasses can override this to set per-resource defaults without overriding create().

              create_opts = CreateOpts(request_key=None,
              response_key=<Unset.UNSET: 'UNSET'>, method='POST',
              requires_id=<Unset.UNSET: 'UNSET'>, response_has_body=True)

allow_create = True — Allow create operation for this resource.
allow_fetch = True — Allow get operation for this resource.
allow_delete = True — Allow delete operation for this resource.
allow_list = True — Allow list operation for this resource.
created_at — Properties Timestamp when the zone was created
links — Links contains a self pertaining to this zone or a next pertaining to next page
message — Message
metadata — Returns the total_count of resources matching this filter
project_id — The project id which the zone belongs to
status — Current status of the zone export
updated_at — Timestamp when the zone was last updated
version — Version of the resource
zone_id — ID for the zone that was created by this export

🦋 openstack.dns.v2.zone_import 🦋

The ZoneImport Class 💜

The DNS class inherits from Resource <#openstack.resource.Resource>.

class openstack.dns.v2.zone_import.ZoneImport(_synchronized=False, connection=None, **attrs)

DNS Zone Import Resource 🌟

The base resource

Parameters

_synchronized — This is not intended to be used directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
connection — Reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.
resource_key = '' — Singular form of key for resource.
resources_key = 'imports' — Plural form of key for resource.
base_path = '/zones/tasks/imports' — The base part of the URI for this resource.
create_opts — Class-level configuration for the create operation. Subclasses can override this to set per-resource defaults without overriding create().

              create_opts = CreateOpts(request_key=None,
              response_key=<Unset.UNSET: 'UNSET'>, method='POST',
              requires_id=<Unset.UNSET: 'UNSET'>, response_has_body=True)

allow_create = True — Allow create operation for this resource.
allow_fetch = True — Allow get operation for this resource.
allow_delete = True — Allow delete operation for this resource.
allow_list = True — Allow list operation for this resource.
created_at — Properties Timestamp when the zone was created
links — Links contains a self pertaining to this zone or a next pertaining to next page
message — Message
metadata — Returns the total_count of resources matching this filter
project_id — The project id which the zone belongs to
status — Current status of the zone import
updated_at — Timestamp when the zone was last updated
version — Version of the resource
zone_id — ID for the zone that was created by this import

The ZoneShare Class 🫶

The DNS class inherits from Resource <#openstack.resource.Resource>.

class openstack.dns.v2.zone_share.ZoneShare(_synchronized=False, connection=None, **attrs)

DNS ZONE Share Resource 🔥

The base resource

Parameters

_synchronized — This is not intended to be used directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
connection — Reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.
resources_key = 'shared_zones' — Plural form of key for resource.
base_path = '/zones/%(zone_id)s/shares' — The base part of the URI for this resource.
allow_create = True — you can create this resource, yes ma'am ✨
allow_delete = True — and you can yeet it too 💅
allow_fetch = True — get/fetch is allowed, go off
allow_list = True — listing? allowed, obviously 🫶
zone_id — the ID of the zone being shared, keeping it cute and identifiable
created_at — timestamp of when the share was created 🎀
updated_at — timestamp of when the member was last updated
project_id — the project ID that owns the share, main character energy fr
target_project_id — the target project ID that the zone is shared with

🦋 openstack.dns.v2.zone_transfer

The `ZoneTransferRequest` Class

okay so this DNS class inherits from Resource <#openstack.resource.Resource>, slay 💖

class openstack.dns.v2.zone_transfer.ZoneTransferRequest(_synchronized=False, connection=None, **attrs)

DNS Zone Transfer Request Resource — that's the whole vibe. It's the base resource.

Parameters (yes, both of them, no skipping 🙈)

_synchronized — bestie, do not use this directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing> instead, okay?
connection — a reference to the Connection being used. Defaults to None so Resource objects can exist without an active Connection (like in unit tests, iykyk). Any use of self._connection in Resource code should protect itself with a check for None.
base_path = '/zones/tasks/transfer_requests' — the base part of the URI for this resource, literally
resources_key = 'transfer_requests' — plural form of the key for the resource
allow_create = True — create is allowed ✨
allow_fetch = True — fetch is allowed
allow_delete = True — delete is allowed
allow_list = True — list is allowed
allow_commit = True — update is allowed too, we love range 🔥
description — description. That's it. That's the description 💀
target_project_id — a project ID that the request will be limited to. No other project will be allowed to accept this request. Exclusive. Periodt 👑
zone_name — name for the zone that's being exported

The `ZoneTransferAccept` Class

same deal, this DNS class inherits from Resource <#openstack.resource.Resource> 🧚

class openstack.dns.v2.zone_transfer.ZoneTransferAccept(_synchronized=False, connection=None, **attrs)

DNS Zone Transfer Accept Resource — the base resource 💜

Parameters

_synchronized — again, not for direct use. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
connection — reference to the Connection being used. Defaults to None so Resource objects can be used without an active Connection, like in unit tests. Use of self._connection in Resource code should protect itself with a check for None.
base_path = '/zones/tasks/transfer_accepts' — the base part of the URI for this resource
resources_key = 'transfer_accepts' — plural form of the key for the resource
allow_create = True — create: allowed 🌸
allow_fetch = True — fetch: allowed
allow_list = True — list: allowed
zone_transfer_request_id — name for the zone that's being exported (yes, that's what the doc says, no I'm not changing it 💀)

🎀 Identity Resources

Identity v2 Resources

openstack.identity.v2.extension

The `Extension` Class

this Extension class inherits from Resource <#openstack.resource.Resource>, iconic ⭐

class openstack.identity.v2.extension.Extension(_synchronized=False, connection=None, **attrs)

the base resource, as ever 🫶

Parameters

_synchronized — nope, not meant for direct use. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
connection — reference to the Connection being used. Defaults to None so Resource objects work without an active Connection (unit tests say hi). Use of self._connection in Resource code should protect itself with a check for None.
resource_key = 'extension' — singular form of the key for the resource
resources_key = 'extensions' — plural form of the key for the resource
base_path = '/extensions' — the base part of the URI for this resource
allow_list = True — list is allowed
allow_fetch = True — fetch is allowed
alias — a unique identifier which will be used for accessing the extension through a dedicated url /extensions/*alias*. The extension alias uniquely identifies an extension and is prefixed by a vendor identifier. Type: string
description — a description of the extension. Type: string
links — links to the documentation in various format. Type: string
name — the name of the extension. Type: string
namespace — the second unique identifier of the extension after the alias. It's usually a URL which will be used. Example: http://docs.openstack.org/identity/api/ext/s3tokens/v1.0. Type: string
updated_at — the last time the extension has been modified (update date)

`classmethod list(...)` — the big one 👑

classmethod list(session, paginated=True, base_path=None, allow_unknown_params=False, *, microversion=None, headers=None, max_items=None, **params)

This method is a generator which yields resource objects 💖 It handles pagination and takes query params so you can filter your little heart out.

Parameters

session — the session to use for making this request
paginated — True if a GET to this resource returns a paginated series of responses, or False if a GET returns only one page of data. When paginated is False only one page of data will be returned, regardless of whether the API supports pagination. no cap.
base_path — base part of the URI for listing resources, if it's different from base_path <#openstack.resource.Resource.base_path>
allow_unknown_params — True to accept but discard unknown query parameters. This lets you get a list of 'filters' and pass everything known to the server. False will result in a validation exception when unknown query parameters are passed 😭
microversion — API version to override the negotiated one
headers — additional headers to inject into the HTTP request
max_items — the maximum number of items to return. Typically this must be used with paginated=True.
params — these keyword arguments get passed through the _transpose() method to find if any of them match expected query parameters to be sent in the params argument to get(). They're additionally checked against the base_path <#openstack.resource.Resource.base_path> format string to see if any path fragments need to be filled in by the contents of this argument. Parameters supported as filters by the server side are passed in the API call, and the remaining parameters are applied as filters to the retrieved results. chef's kiss 💅

Returns — a generator of Resource objects ✨

Raises MethodNotSupported <#openstack.exceptions.MethodNotSupported> if Resource.allow_list is not set to True.

Raises InvalidResourceQuery <#openstack.exceptions.InvalidResourceQuery> if the query contains invalid params.

openstack.identity.v2.role

The `Role` Class

the Role class inherits from Resource <#openstack.resource.Resource>, your honor 🌈

class openstack.identity.v2.role.Role(_synchronized=False, connection=None, **attrs)

the base resource, again, always 🎀

Parameters

_synchronized — please do not use directly, bestie. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
connection — reference to the Connection being used. Defaults to None so Resource objects can be used without an active Connection, e.g. in unit tests. Use of self._connection in Resource code should protect itself with a check for None.
resource_key = 'role' — singular form of the key for the resource
resources_key = 'roles' — plural form of the key for the resource
base_path = '/OS-KSADM/roles' — the base part of the URI for this resource, exactly like that, don't touch it 💅
allow_create = True — create: allowed
allow_fetch = True — fetch: allowed
allow_commit = True — update: allowed
allow_delete = True — delete: allowed
allow_list = True — list: allowed
description — the description of the role. Type: string

Okay, finishing the role fields real quick:

is_enabled — set this attribute to False and this role is literally not available in the role list anymore. Type: bool
name — unique role name, no duplicates bestie. Type: string

🎀 `openstack.identity.v2.tenant` — The Tenant Class

The Tenant class inherits from Resource, as it should.

class openstack.identity.v2.tenant.Tenant(_synchronized=False, connection=None, **attrs)

This is the base resource.

Parameters

_synchronized — not intended to be used directly, bestie. See new() and existing() for the actual moves.
connection — reference to the Connection being used. Defaults to None so Resource objects can exist without an active Connection, like in unit tests. If you're using self._connection in Resource code, protect it with a check for None. Periodt.
resource_key = 'tenant' — singular form of the key for this resource.
resources_key = 'tenants' — plural form of the key for this resource.
base_path = '/tenants' — the base part of the URI for this resource.
allow_create = True — create operation is allowed for this resource.
allow_fetch = True — get operation is allowed for this resource.
allow_commit = True — update operation is allowed for this resource.
allow_delete = True — delete operation is allowed for this resource.
allow_list = True — list operation is allowed for this resource.
description — the description of the tenant. Type: string
is_enabled — setting this attribute to False prevents users from authorizing against this tenant. Also, all pre-existing tokens authorized for the tenant are immediately invalidated. Re-enabling a tenant does not re-enable those pre-existing tokens, so don't think you can just flip it back and pretend nothing happened. Type: bool
name — unique tenant name. Type: string

🦋 `openstack.identity.v2.user` — The User Class

The User class inherits from Resource, naturally.

class openstack.identity.v2.user.User(_synchronized=False, connection=None, **attrs)

This is the base resource.

Parameters

_synchronized — not for direct use, bestie. See new() and existing().
connection — reference to the Connection being used. Defaults to None so Resource objects can work without an active Connection, like in unit tests. Use of self._connection in Resource code should protect itself with a None check.
resource_key = 'user' — singular form of the key for this resource.
resources_key = 'users' — plural form of the key for this resource.
base_path = '/users' — the base part of the URI for this resource.
allow_create = True — create operation is allowed for this resource.
allow_fetch = True — get operation is allowed for this resource.
allow_commit = True — update operation is allowed for this resource.
allow_delete = True — delete operation is allowed for this resource.
allow_list = True — list operation is allowed for this resource.
email — the email of this user. Type: string
is_enabled — setting this value to False prevents the user from authenticating or receiving authorization. Also, all pre-existing tokens held by the user are immediately invalidated. Re-enabling a user does not re-enable pre-existing tokens. Type: bool
name — the name of this user. Type: string

🌈 Identity v3 Resources

💜 `openstack.identity.v3.application_credential` — The ApplicationCredential Class

The ApplicationCredential class inherits from Resource.

class openstack.identity.v3.application_credential.ApplicationCredential(_synchronized=False, connection=None, **attrs)

This is the base resource.

Parameters

_synchronized — not intended to be used directly. See new() and existing().
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.
resource_key = 'application_credential' — singular form of the key for this resource.
resources_key = 'application_credentials' — plural form of the key for this resource.
base_path = '/users/%(user_id)s/application_credentials' — the base part of the URI for this resource.
allow_create = True — create operation is allowed for this resource.
allow_fetch = True — get operation is allowed for this resource.
allow_commit = True — update operation is allowed for this resource.
allow_delete = True — delete operation is allowed for this resource.
allow_list = True — list operation is allowed for this resource.
user_id — user ID using the application credential. Type: string
user — user object using the application credential. Type: string
links — the links for the application credential resource.
name — name of the user. Type: string
description — description of the application credential's purpose. Type: string
expires_at — expire time of the application credential. Type: string
roles — roles of the user. Type: list
unrestricted — restricts the application credential. Type: boolean
project_id — ID of project. Type: string
access_rules — access rules for the application credential. Type: list

🔥 `openstack.identity.v3.credential` — The Credential Class

The Credential class inherits from Resource.

class openstack.identity.v3.credential.Credential(_synchronized=False, connection=None, **attrs)

This is the base resource.

Parameters

_synchronized — not intended to be used directly. See new() and existing().
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.
resource_key = 'credential' — singular form of the key for this resource.
resources_key = 'credentials' — plural form of the key for this resource.
base_path = '/credentials' — the base part of the URI for this resource.
allow_create = True — create operation is allowed for this resource.
allow_fetch = True — get operation is allowed for this resource.
allow_commit = True — update operation is allowed for this resource.
allow_delete = True — delete operation is allowed for this resource.
allow_list = True — list operation is allowed for this resource.
commit_method = 'PATCH' — method for committing a resource. This must be PATCH if allow_patch is True.
blob — arbitrary blob of the credential data, to be parsed according to the type. Type: string
project_id — references a project ID which limits the scope the credential applies to. This attribute is mandatory if the credential type is ec2. Type: string
type — representing the credential type, such as ec2 or cert. A specific implementation may determine the list of supported types. Type: string
user_id — references the user ID which owns the credential. Type: string

👑 `openstack.identity.v3.domain` — The Domain Class

The Domain class inherits from Resource.

class openstack.identity.v3.domain.Domain(_synchronized=False, connection=None, **attrs)

This is the base resource.

Parameters

_synchronized — not intended to be used directly. See new() and existing().
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.
resource_key = 'domain' — singular form of the key for this resource.
resources_key = 'domains' — plural form of the key for this resource.
base_path = '/domains' — the base part of the URI for this resource.
allow_create = True — create operation is allowed for this resource.
allow_fetch = True — get operation is allowed for this resource.
allow_commit = True — update operation is allowed for this resource.
allow_delete = True — delete operation is allowed for this resource.
allow_list = True — list operation is allowed for this resource.
commit_method = 'PATCH' — method for committing a resource. This must be PATCH if allow_patch is True.
description — the description of this domain. Type: string
is_enabled — set this to False and like… users can't authorize against this domain or any project it owns, and users owned by the domain can't authenticate or get any other authorization, periodt. And bestie, hear me: every pre-existing token that applies to all those entities gets immediately invalidated. Re-enabling the domain does not bring those old tokens back. Type: bool 💀
options — the resource options for the project. Heads up: available resource options are immutable. Not me trying to change them 🙈
links — the links related to the domain resource. ✨
assign_role_to_user(session, user, role, inherited) — assign role to user on domain. Slay, give them the role 👑
validate_user_has_role(session, user, role, inherited) — validates that a user has a role on a domain. The vibe check, but for permissions 🫶
unassign_role_from_user(session, user, role, inherited) — unassigns a role from a user on a domain. Revoking rights, we hate to see it but we respect it 😭
assign_role_to_group(session, group, role, inherited) — assign role to group on domain. Group chat gets the power 🌈
validate_group_has_role(session, group, role, inherited) — validates that a group has a role on a domain. Checking receipts on the group's permissions 🧾
unassign_role_from_group(session, group, role, inherited) — unassigns a role from a group on a domain. Taking it back, no hard feelings ✨

🦋 `openstack.identity.v3.domain_config`

The Domain Class

The DomainConfig class inherits from Resource <#openstack.resource.Resource>. Family tree is giving legacy, honestly.

class openstack.identity.v3.domain_config.DomainConfig(_synchronized=False, connection=None, **attrs)

The base resource 💅

Parameters

_synchronized — literally not meant to be used directly, bestie. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
connection — reference to the Connection being used. Defaults to None so that Resource objects can be used without an active Connection, like in unit tests. Use of self._connection in Resource code should protect itself with a check for None. Stay safe out there 🫶
resource_key = 'config' — singular form of key for resource.
base_path = '/domains/%(domain_id)s/config' — the base part of the URI for this resource 🔗
requires_id = False — do calls for this resource require an ID? Nope, bestie, not this one.
commit_method = 'PATCH' — method for committing a resource. This must be PATCH if allow_patch is True. The way it has to be PATCH, no cap.
create_opts = CreateOpts(request_key=<Unset.UNSET: 'UNSET'>, response_key=<Unset.UNSET: 'UNSET'>, method='PUT', requires_id=False, response_has_body=True) — class-level configuration for the create operation. Subclasses can override this to set per-resource defaults without overriding create(). Iconic inheritance behaviour honestly 🎀
allow_create = True — allow create operation for this resource.
allow_fetch = True — allow get operation for this resource.
allow_commit = True — allow update operation for this resource.
allow_delete = True — allow delete operation for this resource.
domain_id — the domain ID.
identity — an identity object ✨
ldap — the config object.

🌸 `openstack.identity.v3.endpoint`

The Endpoint Class

The Endpoint class inherits from Resource <#openstack.resource.Resource>. Bestie, this one does have an ID.

class openstack.identity.v3.endpoint.Endpoint(_synchronized=False, connection=None, **attrs)

The base resource 💅

Parameters

_synchronized — not intended to be used directly, periodt. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.
resource_key = 'endpoint' — singular form of key for resource.
resources_key = 'endpoints' — plural form of key for resource. Plural era 🌈
base_path = '/endpoints' — the base part of the URI for this resource.
allow_create = True — allow create operation for this resource.
allow_fetch = True — allow get operation for this resource.
allow_commit = True — allow update operation for this resource.
allow_delete = True — allow delete operation for this resource.
allow_list = True — allow list operation for this resource. Yes, you can see them all 💅
commit_method = 'PATCH' — method for committing a resource. This must be PATCH if allow_patch is True.
interface — describes the interface of the endpoint according to one of the following values:
- public: intended for consumption by end users, generally on a publicly available network interface 🌍
- internal: not intended for consumption by end users, generally on an unmetered internal network interface 🏠
- admin: intended only for consumption by those needing administrative access to the service, generally on a secure network interface 🔐

Type: string

is_enabled — setting this value to False prevents the endpoint from appearing in the service catalog. Type: bool. Ghosting the catalog, honestly 💀
links — the links for the region resource.
region_id — represents the containing region ID of the service endpoint. New in v3.2. Type: string ✨
service_id — references the service ID to which the endpoint belongs. Type: string
url — fully qualified URL of the service endpoint. Type: string 🔗

🧚 `openstack.identity.v3.federation_protocol`

The FederationProtocol Class

The FederationProtocol class inherits from Resource <#openstack.resource.Resource>. Long class name, long vibes.

class openstack.identity.v3.federation_protocol.FederationProtocol(_synchronized=False, connection=None, **attrs)

The base resource 💅

Parameters

_synchronized — nope, don't touch it directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.
resource_key = 'protocol' — singular form of key for resource.
resources_key = 'protocols' — plural form of key for resource.
base_path = '/OS-FEDERATION/identity_providers/%(idp_id)s/protocols' — the base part of the URI for this resource. Look at that path, it's giving ✨federation✨
allow_create = True — allow create operation for this resource.
allow_fetch = True — allow get operation for this resource.
allow_commit = True — allow update operation for this resource.
allow_delete = True — allow delete operation for this resource.
allow_list = True — allow list operation for this resource.
create_opts = CreateOpts(request_key=<Unset.UNSET: 'UNSET'>, response_key=<Unset.UNSET: 'UNSET'>, method='PUT', requires_id=<Unset.UNSET: 'UNSET'>, response_has_body=True) — class-level configuration for the create operation. Subclasses can override this to set per-resource defaults without overriding create(). 🎀
commit_method = 'PATCH' — method for committing a resource. This must be PATCH if allow_patch is True.
name — name of the protocol (read only). Type: string. Read only, so don't even try it bestie 🙈

💜 `openstack.identity.v3.group`

The Group Class

The Group class inherits from Resource <#openstack.resource.Resource>. Group chat but make it IAM.

class openstack.identity.v3.group.Group(_synchronized=False, connection=None, **attrs)

The base resource 💅

Parameters

_synchronized — not intended to be used directly, fr fr. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.
resource_key = 'group' — singular form of key for resource.
resources_key = 'groups' — plural form of key for resource.
base_path = '/groups' — the base part of the URI for this resource.
allow_create = True — allow create operation for this resource.
allow_fetch = True — allow get operation for this resource.
allow_commit = True — allow update operation for this resource.
allow_delete = True — allow delete operation for this resource.
allow_list = True — allow list operation for this resource.
commit_method = 'PATCH' — method for committing a resource. This must be PATCH if allow_patch is True.
description — the description of this group. Type: string ✨
domain_id — references the domain ID which owns the group; if a domain ID is not specified by the client, the Identity service implementation will default it to the domain ID to which the client's token is scoped. Type: string. It just picks one for you, main character energy 👑
name — unique group name, within the owning domain. Type: string 🌸
add_user(session, user) — adds that user to the group, simple as 💅
remove_user(session, user) — yeets the user out of the group
check_user(session, user) — asks the vibes question: does this user actually belong to this group? 🕵️‍♀️

The UserGroup Class

So UserGroup is a subclass of Group — it inherits all the group energy and just does its own thing. It's the the user is in the group resource, iykyk 👑

class openstack.identity.v3.group.UserGroup(_synchronized=False,
connection=None, **attrs)

The base resource — every resource in this library starts from here, it's giving founding mother 🫶

Parameters

_synchronized — bestie, this is not meant to be used directly. Go look at new() and existing() instead (#openstack.resource.Resource.new, #openstack.resource.Resource.existing).
connection — a reference to the Connection being used. It defaults to None so you can use Resource objects with no active Connection at all, like in unit tests. Any code inside Resource that touches self._connection should protect itself with a check for None. Ngl, guard your heart (and your attributes) 💀

base_path = '/users/%(user_id)s/groups' — the base part of the URI for this resource.

user_id — the ID for the user, pulled straight out of the URI of the resource.

allow_create = False — creation? not allowed, we don't do that here 🙅‍♀️

allow_fetch = False — get operation? also no.

allow_commit = False — update? nope.

allow_delete = False — delete? absolutely not.

allow_list = True — but listing? oh we slay, that one's allowed ✨

openstack.identity.v3.identity_provider

The IdentityProvider Class

The IdentityProvider class inherits from Resource (#openstack.resource.Resource) — 10/10 lineage, no notes.

class openstack.identity.v3.identity_provider.IdentityProvider(_synchronized=False,
connection=None, **attrs)

The base resource ✨

Parameters

_synchronized — do not use this directly, seriously. Peep new() and existing() (#openstack.resource.Resource.new, #openstack.resource.Resource.existing).
connection — reference to the Connection in play. Defaults to None so Resource objects work without an active Connection (hello unit tests 👋). Use of self._connection in Resource code should protect itself with a check for None.

resource_key = 'identity_provider' — the singular form of the key for this resource.

resources_key = 'identity_providers' — the plural form, because plurals are a whole vibe now 🌈

base_path = '/OS-FEDERATION/identity_providers' — the base part of the URI for this resource.

allow_create = True — create: yes 💖

allow_fetch = True — get: yes.

allow_commit = True — update: yes.

allow_delete = True — delete: yes.

allow_list = True — list: yes. All five ate, no crumbs 🍓

create_opts = CreateOpts(request_key=<Unset.UNSET: 'UNSET'>, response_key=<Unset.UNSET: 'UNSET'>, method='PUT', requires_id=<Unset.UNSET: 'UNSET'>, response_has_body=True) — class-level configuration for the create operation. Subclasses can override this to set per-resource defaults without overriding create() — iconic design choice honestly 👑

commit_method = 'PATCH' — the method used for committing a resource. It must be PATCH if allow_patch is True. Don't test it, just respect it 🙏

description — a description of this identity provider. Type: string.

is_enabled — whether the identity provider is currently enabled. Type: bool.

remote_ids — remote IDs associated with the identity provider. Type: list.

authorization_ttl — the length of validity in minutes for group memberships. Type: int.

name — the identifier of the identity provider (read only). Type: string.

openstack.identity.v3.limit

The Limit Class

The Limit class inherits from Resource (#openstack.resource.Resource) — limits! boundaries! structure! we love a resource with self-respect 🎀

class openstack.identity.v3.limit.Limit(_synchronized=False,
connection=None, **attrs)

The base resource 🫶

Parameters

_synchronized — not for direct use, bestie. See new() and existing() (#openstack.resource.Resource.new, #openstack.resource.Resource.existing).
connection — reference to the Connection being used. Defaults to None so Resource objects work without an active Connection, like in unit tests. Use of self._connection in Resource code should protect itself with a check for None.

resource_key = 'limit' — singular form of key for resource.

resources_key = 'limits' — plural form of key for resource.

base_path = '/limits' — the base part of the URI for this resource.

allow_create = True — create operation: allowed ✨

allow_fetch = True — get operation: allowed.

allow_commit = True — update operation: allowed.

allow_delete = True — delete operation: allowed.

allow_list = True — list operation: allowed. Full house, we love to see it 💅

commit_method = 'PATCH' — the method for committing a resource. This must be PATCH if allow_patch is True.

create_opts = CreateOpts(request_key=<Unset.UNSET: 'UNSET'>, response_key='limits', method='POST', requires_id=<Unset.UNSET: 'UNSET'>, response_has_body=True) — class-level configuration for the create operation. Subclasses can override this to set per-resource defaults without overriding create(). Note the response_key='limits' and method='POST' — very much on purpose 🔥

domain_id — the ID of the domain. Type: string.

description — user-facing description of the registered_limit. Type: string.

links — the links for the registered_limit resource.

service_id — ID of service. Type: string.

region_id — ID of region, if any. Type: string. (The "if any" is doing a lot of emotional labour there 😭)

resource_name — the resource name. Type: string.

resource_limit — the resource limit value. Type: int.

project_id — ID of project. Type: string.

openstack.identity.v3.mapping

The Mapping Class

The Mapping class inherits from Resource (#openstack.resource.Resource) — mappings, the federated identity girlies' best friend 🧚

class openstack.identity.v3.mapping.Mapping(_synchronized=False,
connection=None, **attrs)

The base resource ⭐

Parameters

_synchronized — please do not use this directly, it's not that kind of parameter. See new() and existing() (#openstack.resource.Resource.new, #openstack.resource.Resource.existing).
connection — reference to the Connection being used. Defaults to None to let Resource objects exist without an active Connection, e.g. in unit tests. Use of self._connection in Resource code should protect itself with a check for None.

resource_key = 'mapping' — singular form of key for resource.

resources_key = 'mappings' — plural form of key for resource.

base_path = '/OS-FEDERATION/mappings' — the base part of the URI for this resource.

allow_create = True — create: yes 🌸

allow_fetch = True — get: yes.

allow_commit = True — update: yes.

allow_delete = True — delete: yes.

allow_list = True — list: yes. All of them green, we're thriving 🌱

commit_method = 'PATCH' — method for committing a resource. This must be PATCH if allow_patch is True.

rules — the rules of this mapping. Type: list. The rules! we live by them 📜

schema_version — the attribute mapping schema version. Type: string.

name — the identifier of the mapping. Type: string.

openstack.identity.v3.policy

The Policy Class

The Policy class inherits from Resource (#openstack.resource.Resource) — policies, the main character energy of access control 👑

class openstack.identity.v3.policy.Policy(_synchronized=False,
connection=None, **attrs)

The base resource 💜

Parameters

_synchronized — not intended for direct use. See new() and existing() (#openstack.resource.Resource.new, #openstack.resource.Resource.existing).
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.

resource_key = 'policy' — singular form of key for resource.

resources_key = 'policies' — plural form of key for resource.

base_path = '/policies' — the base part of the URI for this resource.

allow_create = True — create operation: allowed 💖

allow_fetch = True — get operation: allowed.

allow_commit = True — update operation: allowed.

allow_delete = True — delete operation: allowed.

allow_list = True — list operation: allowed. Every flag set to True, periodt ✨

commit_method = 'PATCH' — method for committing a resource. This must be PATCH if allow_patch is True.

blob — the policy rule set itself, as a serialized blob. Type: string ✨
links — the links for the policy resource 🔗
project_id — the ID for the project 🫶
type — the MIME Media Type of the serialized policy blob. Type: string 💅
user_id — the ID of the user who owns the policy 👑

🌸 `openstack.identity.v3.project`

🫶 The Project Class

The Project class inherits from Resource <#openstack.resource.Resource>. Bestie, it's giving "whole project energy" and honestly? Iconic. 💖

class openstack.identity.v3.project.Project(_synchronized=False,
connection=None, **attrs)

The base resource 😌

Parameters

_synchronized — This is not intended to be used directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>. 🔒
connection — Reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None. 🧪
resource_key = 'project' — singular form of key for resource 🎀
resources_key = 'projects' — plural form of key for resource 🎀
base_path = '/projects' — the base part of the URI for this resource 🛣️
allow_create = True — allow create operation for this resource ✅
allow_fetch = True — allow get operation for this resource ✅
allow_commit = True — allow update operation for this resource ✅
allow_delete = True — allow delete operation for this resource ✅
allow_list = True — allow list operation for this resource ✅
commit_method = 'PATCH' — method for committing a resource. This must be PATCH if allow_patch is True. 💅
description — the description of the project. Type: string 📝
domain_id — references the domain ID which owns the project; if a domain ID is not specified by the client, the Identity service implementation will default it to the domain ID to which the client's token is scoped. Type: string 🌐
is_domain — indicates whether the project also acts as a domain. If set to True, the project acts as both a project and a domain. Default is False. New in version 3.6 ✨
is_enabled — setting this attribute to False prevents users from authorizing against this project. Additionally, all pre-existing tokens authorized for the project are immediately invalidated. Re-enabling a project does not re-enable pre-existing tokens. Type: bool ⚠️
options — the resource options for the project. Available resource options are immutable. 🔒
parent_id — the ID of the parent of the project. New in version 3.4 🧬
links — the links related to the project resource 🔗
assign_role_to_user(session, user, role, inherited) — assign role to user on project 👑
validate_user_has_role(session, user, role, inherited) — validates that a user has a role on a project ✅
unassign_role_from_user(session, user, role, inherited) — unassigns a role from a user on a project ❌
assign_role_to_group(session, group, role, inherited) — assign role to group on project 👥
validate_group_has_role(session, group, role, inherited) — validates that a group has a role on a project ✅
unassign_role_from_group(session, group, role, inherited) — unassigns a role from a group on a project ❌
associate_endpoint(session, endpoint_id) — associate endpoint with project. 🫶

Parameters

session — The session to use for making this request.
endpoint_id — The ID of an endpoint.

Returns

None

disassociate_endpoint(session, endpoint_id) — disassociate endpoint from project. 💔

Parameters

session — The session to use for making this request.
endpoint_id — The ID of an endpoint.

Returns

None

🦋 `openstack.identity.v3.region`

💅 The Region Class

The Region class inherits from Resource <#openstack.resource.Resource>. Regional queen behavior, no cap. 👑

class openstack.identity.v3.region.Region(_synchronized=False,
connection=None, **attrs)

The base resource 😌

Parameters

_synchronized — This is not intended to be used directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>. 🔒
connection — Reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None. 🧪
resource_key = 'region' — singular form of key for resource 🎀
resources_key = 'regions' — plural form of key for resource 🎀
base_path = '/regions' — the base part of the URI for this resource 🛣️
allow_create = True — allow create operation for this resource ✅
allow_fetch = True — allow get operation for this resource ✅
allow_commit = True — allow update operation for this resource ✅
allow_delete = True — allow delete operation for this resource ✅
allow_list = True — allow list operation for this resource ✅
commit_method = 'PATCH' — method for committing a resource. This must be PATCH if allow_patch is True. 💅
description — user-facing description of the region. Type: string 📝
links — the links for the region resource 🔗
parent_region_id — ID of parent region, if any. Type: string 🧬

🌈 `openstack.identity.v3.registered_limit`

🎀 The RegisteredLimit Class

The RegisteredLimit class inherits from Resource <#openstack.resource.Resource>. Limits? Registered. Vibes? Immaculate. ✨

class openstack.identity.v3.registered_limit.RegisteredLimit(_synchronized=False, connection=None, **attrs)

The base resource 😌

Parameters

_synchronized — This is not intended to be used directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>. 🔒
connection — Reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None. 🧪
resource_key = 'registered_limit' — singular form of key for resource 🎀
resources_key = 'registered_limits' — plural form of key for resource 🎀
base_path = '/registered_limits' — the base part of the URI for this resource 🛣️
allow_create = True — allow create operation for this resource ✅
allow_fetch = True — allow get operation for this resource ✅
allow_commit = True — allow update operation for this resource ✅
allow_delete = True — allow delete operation for this resource ✅
allow_list = True — allow list operation for this resource ✅
commit_method = 'PATCH' — method for committing a resource. This must be PATCH if allow_patch is True. 💅
create_opts — CreateOpts(request_key=<Unset.UNSET: 'UNSET'>, response_key='registered_limits', method='POST', requires_id=<Unset.UNSET: 'UNSET'>, response_has_body=True). Class-level configuration for the create operation. Subclasses can override this to set per-resource defaults without overriding create(). 🛠️
description — user-facing description of the registered_limit. Type: string 📝
links — the links for the registered_limit resource 🔗
service_id — ID of service. Type: string 🛎️
region_id — ID of region, if any. Type: string 🌍
resource_name — the resource name. Type: string 🏷️
default_limit — the default limit value. Type: int 🔢

🌸 `openstack.identity.v3.role`

👑 The Role Class

The Role class inherits from Resource <#openstack.resource.Resource>. It's giving main-character permissions, fr fr. 💅

class openstack.identity.v3.role.Role(_synchronized=False,
connection=None, **attrs)

The base resource 😌

Parameters

_synchronized — This is not intended to be used directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>. 🔒
connection — Reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None. 🧪
resource_key = 'role' — singular form of key for resource 🎀
resources_key = 'roles' — plural form of key for resource 🎀
base_path = '/roles' — the base part of the URI for this resource 🛣️
allow_create = True — allow create operation for this resource ✅
allow_fetch = True — allow get operation for this resource ✅
allow_commit = True — allow update operation for this resource ✅
allow_delete = True — allow delete operation for this resource ✅
allow_list = True — allow list operation for this resource ✅
commit_method = 'PATCH' — method for committing a resource. This must be PATCH if allow_patch is True. 💅
name — the role's unique name, scoped inside the domain that owns it. Type: string
- description — the user-facing description of the role. Type: string
- domain_id — references the domain ID that owns the role. Type: string
- options — the resource options for the role. Heads up bestie: the available resource options are immutable, so no take-backsies. 🫶
- links — the links for the service resource.

`openstack.identity.v3.role_assignment`

The RoleAssignment Class ✨

The RoleAssignment class inherits from Resource <#openstack.resource.Resource>.

class openstack.identity.v3.role_assignment.RoleAssignment(_synchronized=False,
        connection=None, **attrs)

The base resource 💅

Parameters

_synchronized — nope, don't touch this one directly, it's not meant to be used like that. Peep new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing> instead.
connection — a reference to the Connection being used. Defaults to None so you can make Resource objects without an active Connection (think unit tests, iconic behaviour). Any use of self._connection in Resource code should protect itself with a check for None.

resource_key = 'role_assignment' — singular form of key for resource.
resources_key = 'role_assignments' — plural form of key for resource.
base_path = '/role_assignments' — the base part of the URI for this resource.
allow_list = True — allow list operation for this resource.
links — the links for the service resource.
role — the role (dictionary contains only id).
scope — the scope (either domain or project; dictionary contains only id).
user — the user (dictionary contains only id).
group — the group (dictionary contains only id).

`openstack.identity.v3.role_domain_group_assignment`

The RoleDomainGroupAssignment Class 🦋

The RoleDomainGroupAssignment class inherits from Resource <#openstack.resource.Resource>.

class openstack.identity.v3.role_domain_group_assignment.RoleDomainGroupAssignment(_synchronized=False,
        connection=None, **attrs)

The base resource ✨

Parameters

_synchronized — again, not for direct use, bestie. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
connection — reference to the Connection being used. Defaults to None so Resource objects work without an active Connection, like in unit tests. Code that uses self._connection should guard with a None check.

resource_key = 'role' — singular form of key for resource.
resources_key = 'roles' — plural form of key for resource.
base_path = '/domains/%(domain_id)s/groups/%(group_id)s/roles' — the base part of the URI for this resource.
allow_list = True — allow list operation for this resource.
name — name of the role. Type: string
links — the links for the service resource.
domain_id — the ID of the domain to list assignment from. Type: string
group_id — the ID of the group to list assignment from. Type: string

`openstack.identity.v3.role_domain_user_assignment`

The RoleDomainUserAssignment Class 🎀

The RoleDomainUserAssignment class inherits from Resource <#openstack.resource.Resource>.

class openstack.identity.v3.role_domain_user_assignment.RoleDomainUserAssignment(_synchronized=False,
        connection=None, **attrs)

The base resource 💖

Parameters

_synchronized — do not use directly, fr fr. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
connection — reference to the Connection being used. Defaults to None so Resource objects can exist without an active Connection, like in unit tests. self._connection usage inside Resource code should protect itself with a None check.

resource_key = 'role' — singular form of key for resource.
resources_key = 'roles' — plural form of key for resource.
base_path = '/domains/%(domain_id)s/users/%(user_id)s/roles' — the base part of the URI for this resource.
allow_list = True — allow list operation for this resource.
name — name of the role. Type: string
links — the links for the service resource.
domain_id — the ID of the domain to list assignment from. Type: string
user_id — the ID of the user to list assignment from. Type: string

`openstack.identity.v3.role_project_group_assignment`

The RoleProjectGroupAssignment Class 🌸

The RoleProjectGroupAssignment class inherits from Resource <#openstack.resource.Resource>.

class openstack.identity.v3.role_project_group_assignment.RoleProjectGroupAssignment(_synchronized=False,
        connection=None, **attrs)

The base resource ⭐

Parameters

_synchronized — not meant to be used directly, okay? See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
connection — reference to the Connection being used. Defaults to None so Resource objects can be used without an active Connection, e.g. in unit tests. Use of self._connection in Resource code should protect itself with a check for None.

resource_key = 'role' — singular form of key for resource.
resources_key = 'roles' — plural form of key for resource.
base_path = '/projects/%(project_id)s/groups/%(group_id)s/roles' — the base part of the URI for this resource.
allow_list = True — allow list operation for this resource.
name — name of the role. Type: string
links — the links for the service resource.
project_id — the ID of the project to list assignment from. Type: string
group_id — the ID of the group to list assignment from. Type: string

`openstack.identity.v3.role_project_user_assignment`

The RoleProjectUserAssignment Class 🧚

The RoleProjectUserAssignment class inherits from Resource <#openstack.resource.Resource>.

class openstack.identity.v3.role_project_user_assignment.RoleProjectUserAssignment(_synchronized=False,
        connection=None, **attrs)

The base resource 💜

Parameters

_synchronized — this one's not for direct use, bestie. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.

resource_key = 'role' — singular form of key for resource.
resources_key = 'roles' — plural form of key for resource.
base_path = '/projects/%(project_id)s/users/%(user_id)s/roles' — the base part of the URI for this resource.
allow_list = True — allow list operation for this resource.
name — name of the role. Type: string
links — the links for the service resource.
project_id — the ID of the project to list assignment from. Type: string
user_id — the ID of the user to list assignment from. Type: string

`openstack.identity.v3.role_system_group_assignment`

The RoleSystemGroupAssignment Class 🔥

The RoleSystemGroupAssignment class inherits from Resource <#openstack.resource.Resource>.

class openstack.identity.v3.role_system_group_assignment.RoleSystemGroupAssignment(_synchronized=False,
        connection=None, **attrs)

The base resource 👑

Parameters

_synchronized — no direct use, ngl. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
connection — reference to the Connection being used. Defaults to None so Resource objects can exist without an active Connection, like in unit tests. Use of self._connection in Resource code should protect itself with a check for None.

resource_key = 'role' — singular form of key for resource.
resources_key = 'roles' — plural form of key for resource.
base_path = '/system/groups/%(group_id)s/roles' — the base part of the URI for this resource.
allow_list = True — allow list operation for this resource.
group_id — the ID of the group to list assignment from. Type: string
system_id — the name of the system to list assignment from. Type: string

`openstack.identity.v3.role_system_user_assignment`

The RoleSystemUserAssignment Class 🦋

The RoleSystemUserAssignment class inherits from Resource <#openstack.resource.Resource>.

class openstack.identity.v3.role_system_user_assignment.RoleSystemUserAssignment(_synchronized=False,
        connection=None, **attrs)

The base resource 💫

Parameters

_synchronized — not intended to be used directly, periodt. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.

resource_key = 'role' — singular form of key for resource.
allow_list = True — allow the list operation for this resource ✨
base_path = '/system/users/%(user_id)s/roles' — the base part of the URI for this resource 🎀
resources_key = 'roles' — the plural form of the key for the resource 💅
allow_list = True — allow the list operation for this resource ✨
system_id — the name of the system to list assignment from. Type: string
user_id — the ID of the user to list assignment from. Type: string

🌈 `openstack.identity.v3.service`

💖 The Service Class

okay so the Service class inherits from Resource (that's <#openstack.resource.Resource> bestie, keep up 🫶).

class openstack.identity.v3.service.Service(_synchronized=False,
connection=None, **attrs)

The base resource 🌸

Parameters — the deets 👑

_synchronized — literally not meant to be used directly. See new() (<#openstack.resource.Resource.new>) and existing() (<#openstack.resource.Resource.existing>) instead 🙈
connection — reference to the Connection being used. Defaults to None so Resource objects can be used without an active Connection, like in unit tests ngl. Use of self._connection in Resource code should protect itself with a check for None 💀
resource_key = 'service' — the singular form of the key for the resource
resources_key = 'services' — the plural form of the key for the resource
base_path = '/services' — the base part of the URI for this resource 🦋
allow_create = True — allow the create operation for this resource ✨
allow_fetch = True — allow the get operation for this resource ✨
allow_commit = True — allow the update operation for this resource ✨
allow_delete = True — allow the delete operation for this resource ✨
allow_list = True — allow the list operation for this resource ✨
commit_method = 'PATCH' — the method for committing a resource. This must be PATCH if allow_patch is True 💅
description — user-facing description of the service. Type: string
is_enabled — setting this value to False prevents the service and its endpoints from appearing in the service catalog. Type: bool
links — the links for the service resource
name — user-facing name of the service. Type: string
type — describes the API implemented by the service. The following values are recognized within the OpenStack ecosystem: compute, image, ec2, identity, volume, network. To support non-core and future projects, the value should not be validated against this list. Type: string 🔥

🦋 `openstack.identity.v3.system`

💜 The System Class

the System class inherits from Resource (<#openstack.resource.Resource>), obviously 💅

class openstack.identity.v3.system.System(_synchronized=False,
connection=None, **attrs)

The base resource 🌸

Parameters — again, the essentials 🎀

_synchronized — not intended to be used directly, periodt. See new() (<#openstack.resource.Resource.new>) and existing() (<#openstack.resource.Resource.existing>)
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None 🙈
resource_key = 'system' — the singular form of the key for the resource
base_path = '/system' — the base part of the URI for this resource 🌈
assign_role_to_user(session, user, role) — assign role to user on system ✨
validate_user_has_role(session, user, role) — validates that a user has a role on a system 👑
unassign_role_from_user(session, user, role) — unassigns a role from a user on a system 💀
assign_role_to_group(session, group, role) — assign role to group on system ✨
validate_group_has_role(session, group, role) — validates that a group has a role on a system 👑
unassign_role_from_group(session, group, role) — unassigns a role from a group on a system 💀

🎀 `openstack.identity.v3.token`

⭐ The Token Class

the Token class inherits from Resource (<#openstack.resource.Resource>) 🫶

class openstack.identity.v3.token.Token(_synchronized=False,
connection=None, **attrs)

The base resource 🌸

Parameters 💖

_synchronized — this is not intended to be used directly. See new() (<#openstack.resource.Resource.new>) and existing() (<#openstack.resource.Resource.existing>)
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None 🙈
resource_key = 'token' — the singular form of the key for the resource
base_path = '/auth/tokens' — the base part of the URI for this resource 🔥
allow_fetch = False — allow get operation for this resource
allow_delete = False — allow delete operation for this resource
allow_list = False — allow list operation for this resource
allow_head = False — allow head operation for this resource 💀
subject_token — an authentication token. This is used rather than X-Auth-Token to allow users to check or revoke a token other than their own 🎀
audit_ids — a list of one or two audit IDs. An audit ID is a unique, randomly generated, URL-safe string that you can use to track a token. The first audit ID is the current audit ID for the token. The second audit ID is present for only re-scoped tokens and is the audit ID from the token before it was re-scoped. A re-scoped token is one that was exchanged for another token of the same or different scope. You can use these audit IDs to track the use of a token or chain of tokens across multiple requests and endpoints without exposing the token ID to non-privileged users 👀 super useful ngl
catalog — the service catalog 🦋
expires_at — the date and time when the token expires
issued_at — the date and time when the token was issued
methods — the authentication method
user — the user that owns the token
project — the project that the token is scoped to, if any
domain — the domain that the token is scoped to, if any
is_domain — whether the project, if set, is acting as a domain
system — the parts of the system the token is scoped to, if system-scoped
roles — the roles associated with the user 💅

🌸 `openstack.identity.v3.trust`

🧚 The Trust Class

the Trust class inherits from Resource (<#openstack.resource.Resource>) 🫶

class openstack.identity.v3.trust.Trust(_synchronized=False,
connection=None, **attrs)

The base resource 🌈

Parameters 💖

_synchronized — not intended to be used directly. See new() (<#openstack.resource.Resource.new>) and existing() (<#openstack.resource.Resource.existing>)
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None 🙈
resource_key = 'trust' — the singular form of the key for the resource
resources_key = 'trusts' — the plural form of the key for the resource
base_path = '/OS-TRUST/trusts' — the base part of the URI for this resource ✨
allow_create = True — allow create operation for this resource ✨
allow_fetch = True — allow get operation for this resource ✨
allow_delete = True — allow delete operation for this resource ✨
allow_list = True — allow list operation for this resource ✨
allow_redelegation — a boolean indicating whether the trust can be issued by the trustee as a regulart trust. Default is False 🎀 (yes bestie, "regulart" is exactly what the original says, don't come for me 💀)
expires_at — specifies the expiration time of the trust. A trust may be revoked ahead of expiration. If the value represents a time in the past, the trust is deactivated ⏰
is_impersonation — if impersonation is set to true, then the user attribute of tokens that are generated based on the trust will represent that of the trustor rather than the trustee, thus allowing the trustee to impersonate the trustor. If impersonation is set to False, then the token's user attribute will represent that of the trustee. Type: bool 👀
links — links for the trust resource
project_id — ID of the project upon which the trustor is delegating authorization. Type: string
role_links — a role links object that includes 'next', 'previous', and self links for roles 🔗
roles — specifies the subset of the trustor's roles on the project_id to be granted to the trustee when the token is consumed. The trustor must already be granted these roles in the project referenced by the project_id attribute. Type: list 👑
redelegated_trust_id — returned with redelegated trust provides information about the predecessor in the trust chain 🦋
redelegation_count — redelegation count 🔢
remaining_uses — how many times this trust can be used to get a token. Every time a token gets issued through the trust, the value goes down. Once it hits zero, no more tokens get issued through the trust. That's the whole vibe.
trustee_user_id — the user ID of the person who can actually consume the trust. Type: string
trustor_user_id — the user ID of the person who created the trust and whose authorization is being delegated. Type: string

✨ `openstack.identity.v3.user` ✨

💖 The User Class 💖

The User class inherits from Resource (openstack.resource.Resource). Iconic.

class openstack.identity.v3.user.User(_synchronized=False,
connection=None, **attrs)

The base resource. Constructor params, bestie:

_synchronized — not meant to be used directly. See new() (openstack.resource.Resource.new) and existing() (openstack.resource.Resource.existing).
connection — reference to the Connection being used. Defaults to None so Resource objects can exist without an active Connection, like in unit tests. If Resource code uses self._connection, it should guard with a None check.
resource_key = 'user' — singular form of the key for this resource.
resources_key = 'users' — plural form of the key for this resource.
base_path = '/users' — the base part of the URI for this resource.
allow_create = True — allow create operation for this resource.
allow_fetch = True — allow get operation for this resource.
allow_commit = True — allow update operation for this resource.
allow_delete = True — allow delete operation for this resource.
allow_list = True — allow list operation for this resource.
commit_method = 'PATCH' — method for committing a resource. This must be PATCH if allow_patch is True.
default_project_id — references the user's default project ID to authorize against, if the API user doesn't explicitly specify one when creating a token. Setting this attribute does not grant any actual authorization on the project — it's just there for the user's convenience. So yes, the referenced project doesn't even need to exist within the user's domain. New in version 3.1: if the user doesn't have authorization to their default project, the default project gets ignored at token creation. Type: string
description — the description of this user. Type: string
domain_id — references the domain ID that owns the user. If the client doesn't specify a domain ID, the Identity service implementation defaults it to the domain ID the client's token is scoped to. Type: string
email — the email of this user. Type: string
is_enabled — setting this to False stops the user from authenticating or receiving authorization. Also, every pre-existing token held by the user is immediately invalidated. Re-enabling the user does not re-enable those pre-existing tokens. Type: bool
links — the links for the user resource.
name — unique user name within the owning domain. Type: string
password — the default form of credential used during authentication. Type: string
password_expires_at — the date and time when the password expires. Time zone is UTC. A None value means the password never expires.

This is a response object attribute, not valid for requests. New in version 3.7.

federated — list of federated identity mappings associated with the user. Each item contains idp_id and protocols (a list of objects with protocol_id and unique_id). New in version 3.14.
options — a dictionary of the user's extra options.
update_password(session, current_password, password) — update the password for this user. Params:
- session — the session to use for the request.
- current_password (str) — the user's current password.
- password (str) — the user's new password.

🌈 Other Resources 🌈

💜 `openstack.identity.version` 💜

The Version Class

The Version class inherits from Resource (openstack.resource.Resource). Slay.

class openstack.identity.version.Version(_synchronized=False,
connection=None, **attrs)

The base resource. Params:

_synchronized — not intended to be used directly. See new() (openstack.resource.Resource.new) and existing() (openstack.resource.Resource.existing).
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.
resource_key = 'version' — singular form of the key for this resource.
resources_key = 'versions' — plural form of the key for this resource.
base_path = '/' — the base part of the URI for this resource.
allow_list = True — allow list operation for this resource.

classmethod list(session, paginated=True, base_path=None, allow_unknown_params=False, *, microversion=None, headers=None, **params)

This method is a generator that yields resource objects. It handles pagination and takes query params for response filtering. Params:

session — the session to use for making this request.
paginated — True if a GET to this resource returns a paginated series of responses, or False if a GET returns only one page of data. When paginated is False, only one page of data will be returned regardless of the API's support of pagination.
base_path — base part of the URI for listing resources, if different from base_path (openstack.resource.Resource.base_path).
allow_unknown_params — True to accept, but discard, unknown query parameters. This allows getting a list of 'filters' and passing everything known to the server. False will result in a validation exception when unknown query parameters are passed.
microversion — API version to override the negotiated one.
headers — additional headers to inject into the HTTP request.
max_items — the maximum number of items to return. Typically this must be used with paginated=True.
params — these keyword arguments are passed through the _transpose() method to find if any of them match expected query parameters to be sent in the params argument to get(). They're additionally checked against the base_path (openstack.resource.Resource.base_path) format string to see if any path fragments need to be filled in by the contents of this argument. Parameters supported as filters by the server side are passed in the API call, remaining parameters are applied as filters to the retrieved results.

Returns: a generator of Resource objects.

Raises: MethodNotSupported (openstack.exceptions.MethodNotSupported) if Resource.allow_list is not set to True.

Raises: InvalidResourceQuery (openstack.exceptions.InvalidResourceQuery) if query contains invalid params.

🦋 Image Resources 🦋

🌸 Image v1 Resources 🌸

💅 `openstack.image.v1.image` 💅

The Image Class

The Image class inherits from Resource (openstack.resource.Resource). Periodt.

class openstack.image.v1.image.Image(_synchronized=False,
connection=None, **attrs)

The base resource. Params:

_synchronized — this is not intended to be used directly. See new() (openstack.resource.Resource.new) and existing() (openstack.resource.Resource.existing).
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.
resource_key = 'image' — singular form of the key for this resource.
resources_key = 'images' — plural form of the key for this resource.
base_path = '/images' — the base part of the URI for this resource.
allow_create = True — allow create operation for this resource.
allow_fetch = True — allow get operation for this resource.
allow_commit = True — allow update operation for this resource.
allow_delete = True — allow delete operation for this resource.
allow_list = True — allow list operation for this resource.
checksum — hash of the image data used. The Image service uses this value for verification.
container_format — so this one's about whether the VM image lives in a file format that also carries metadata about the actual VM. Container formats include OVF and Amazon AMI. Also? A VM image might straight up have no container format at all — in which case it's just a blob of unstructured data, no thoughts, head empty 💅
copy_from — a URL to copy an image from ✨
created_at — the timestamp when this image was created 🎀
disk_format — valid values are: aki, ari, ami, raw, iso, vhd, vdi, qcow2, or vmdk. The disk format of a VM image is the format of the underlying disk image. Virtual appliance vendors all have different formats for laying out the info contained in a VM disk image — iconic of them, honestly 🦋
is_protected — defines whether the image can be deleted. Type: bool 🔒
is_public — True if this is a public image. Type: bool
location — a location for the image identified by a URI
min_disk — the minimum disk size in GB that is required to boot the image 💾
min_ram — the minimum amount of RAM in MB that is required to boot the image
name — name for the image. Note that the name of an image is not unique to a Glance node. The API cannot expect users to know the names of images owned by others 👀
owner — the ID of the owner, or project, of the image
owner_id — the ID of the owner, or project, of the image (backwards compat)
properties — properties, if any, that are associated with the image
size — the size of the image data, in bytes
status — the image status
updated_at — the timestamp when this image was last updated ⭐

🌸 `classmethod find(session, name_or_id, ignore_missing=True, list_base_path=None, *, microversion=None, all_projects=None, **params)`

Find a resource by its name or id, bestie. That's the whole vibe 🫶

Parameters

session (Adapter) — the session to use for making this request.
name_or_id — this resource's identifier, if needed by the request. The default is None.
ignore_missing (bool) — when set to False, NotFoundException will be raised when the resource does not exist. When set to True, None will be returned when attempting to find a nonexistent resource.
params (dict) — any additional parameters to be passed into underlying methods, such as to existing() in order to pass on URI parameters.

Returns

The Resource object matching the given name or id, or None if nothing matches 😭

Raises

openstack.exceptions.DuplicateResource if more than one resource is found for this request.

Raises

openstack.exceptions.NotFoundException if nothing is found and ignore_missing is False.

💜 Image v2 Resources

`openstack.image.v2.image`

👑 The Image Class

The Image class inherits from Resource.

✨ `class openstack.image.v2.image.Image(_synchronized=False, connection=None, **attrs)`

The base resource 💅

Parameters

_synchronized — this is not intended to be used directly. See new() and existing().
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.

resources_key = 'images' — plural form of key for resource.
base_path = '/images' — the base part of the URI for this resource.
allow_create = True — allow create operation for this resource ✅
allow_fetch = True — allow get operation for this resource.
allow_commit = True — allow update operation for this resource.
allow_delete = True — allow delete operation for this resource.
allow_list = True — allow list operation for this resource.
allow_patch = True — allow patch operation for this resource.
commit_method = 'PATCH' — method for committing a resource. This must be PATCH if allow_patch is True. No cap, that's the rule 🔥
checksum — hash of the image data used. The Image service uses this value for verification.
container_format — the container format refers to whether the VM image is in a file format that also contains metadata about the actual VM. Container formats include OVF and Amazon AMI. In addition, a VM image might not have a container format — instead, the image is just a blob of unstructured data.
created_at — the date and time when the image was created.
disk_format — valid values are: aki, ari, ami, raw, iso, vhd, vdi, qcow2, or vmdk. The disk format of a VM image is the format of the underlying disk image. Virtual appliance vendors have different formats for laying out the information contained in a VM disk image.
is_hidden — this field controls whether an image is displayed in the default image-list response 🙈
is_protected — defines whether the image can be deleted. Type: bool
hash_algo — the algorithm used to compute a secure hash of the image data for this image 🔐
hash_value — the hexdigest of the secure hash of the image data computed using the algorithm whose name is the value of the os_hash_algo property.
min_disk — the minimum disk size in GB that is required to boot the image.
min_ram — the minimum amount of RAM in MB that is required to boot the image.
name — the name of the image.
owner — the ID of the owner, or project, of the image.
owner_id — the ID of the owner, or project, of the image (backwards compat).
properties — properties, if any, that are associated with the image.
size — the size of the image data, in bytes.
store — when present, Glance will attempt to store the disk image data in the backing store indicated by the value of the header. When not present, Glance will store the disk image data in the backing store that is marked default. Valid values are: file, s3, rbd, swift, cinder, gridfs, sheepdog, or vsphere 🌈
status — the image status.
updated_at — the date and time when the image was updated.
virtual_size — the virtual size of the image.
visibility — the image visibility 👁️
file — the URL for the virtual machine image file.
locations — a list of URLs to access the image file in external store. This list appears if the show_multiple_locations option is set to true in the Image service's configuration file.
direct_url — the URL to access the image file kept in external store. It appears when you set the show_image_direct_url option to true in the Image service's configuration file.
url — the URL to access the image file kept in external store.
metadata — the location metadata.
architecture — the CPU architecture that must be supported by the hypervisor 🖥️
hypervisor_type — the hypervisor type. Note that qemu is used for both QEMU and KVM hypervisor types.
instance_type_rxtx_factor — optional property allows created servers to have a different bandwidth cap than that defined in the network they are attached to.
instance_uuid — create this image. (that's genuinely all it says, bestie, I'm not hiding anything from you 😭)
needs_config_drive — specifies whether the image needs a config drive. mandatory or optional (default if property is not used).
kernel_id — the ID of an image stored in the Image service that should be used as the kernel when booting an AMI-style image.
os_distro — the common name of the operating system distribution in lowercase.
os_version — the operating system version as specified by the distributor.
needs_secure_boot — Secure Boot is a security standard. When the instance starts, Secure Boot first examines software such as firmware and OS by their signature and only allows them to run if the signatures are valid 🔒
os_shutdown_timeout — time for graceful shutdown.
ramdisk_id — the ID of image stored in the Image service that should be used as the ramdisk when booting an AMI-style image.
vm_mode — the virtual machine mode. This represents the host/guest ABI (application binary interface) used for the virtual machine.
hw_cpu_sockets — the preferred number of sockets to expose to the guest.
hw_cpu_cores — the preferred number of cores to expose to the guest. 🧚
hw_cpu_threads — the preferred number of threads to expose to the guest. 💻
hw_disk_bus — specifies the type of disk controller to attach disk devices to. One of scsi, virtio, uml, xen, ide, or usb.
hw_cpu_policy — used to pin the virtual CPUs (vCPUs) of instances to the host's physical CPU cores (pCPUs). 📌
hw_cpu_thread_policy — defines how hardware CPU threads in a simultaneous multithreading-based (SMT) architecture get used.
hw_rng_model — adds a random-number generator device to the image's instances. 🎲
hw_machine_type — for libvirt: enables booting an ARM system using the specified machine type. For Hyper-V: specifies whether the Hyper-V instance will be a generation 1 or generation 2 VM.
hw_scsi_model — enables the use of VirtIO SCSI (virtio-scsi) to provide block device access for compute instances; by default, instances use VirtIO Block (virtio-blk).
hw_serial_port_count — specifies the count of serial ports that should be provided.
hw_video_model — the video image driver used. 🎬
hw_video_ram — maximum RAM for the video image.
hw_watchdog_action — enables a virtual hardware watchdog device that carries out the specified action if the server hangs. 🐕
os_command_line — the kernel command line to be used by the libvirt driver, instead of the default.
hw_vif_model — specifies the model of virtual network interface device to use.
is_hw_vif_multiqueue_enabled — if true, this enables the virtio-net multiqueue feature. In this case, the driver sets the number of queues equal to the number of guest vCPUs. This makes the network performance scale across a number of vCPUs. 🌐
is_hw_boot_menu_enabled — if true, enables the BIOS bootmenu.
vmware_adaptertype — the virtual SCSI or IDE controller used by the hypervisor.
vmware_ostype — a VMware GuestID which describes the operating system installed in the image.
has_auto_disk_config — if true, the root partition on the disk is automatically resized before the instance boots. 🛠️
os_type — the operating system installed on the image.
os_admin_user — the operating system admin username.
hw_qemu_guest_agent — a string boolean, which if "true", QEMU guest agent will be exposed to the instance.
os_require_quiesce — if true, require quiesce on snapshot via QEMU guest agent.
schema — the URL for the schema describing a virtual machine image. 🔗

deactivate(session) — deactivate an image.

Note: only administrative users can view image locations for deactivated images. 🙈

reactivate(session) — reactivate an image.

Note: the image must exist in order to be reactivated.

💅 `upload(session, *, data=None, size=None)`

Upload data into an existing image. 🫶

Parameters:

session — the session to use for making this request.
data — optional data to be uploaded. If not provided, the ~Image.data attribute will be used.
size — optional size of the data in bytes. Providing this allows Glance to pre-allocate storage and can improve upload performance. If not provided and data is a file-like object, the size will be calculated automatically.

Returns: the server response.

🎀 `stage(session, *, data=None, size=None)`

Stage binary image data into an existing image. ✨

Parameters:

session — the session to use for making this request.
data — optional data to be uploaded. If not provided, the ~Image.data attribute will be used.
size — optional size of the data in bytes. Providing this allows Glance to pre-allocate storage and can improve upload performance. If not provided and data is a file-like object, the size will be calculated automatically.

Returns: the server response.

🌈 `import_image(session, method='glance-direct', *, uri=None, remote_region=None, remote_image_id=None, remote_service_interface=None, store=None, stores=None, all_stores=None, all_stores_must_succeed=None)`

Import Image via interoperable image import process. 🔥

⭐ `classmethod find`

classmethod find(session, name_or_id, ignore_missing=True,
list_base_path=None, *, microversion=None, all_projects=None,
**params)

Find a resource by its name or id. 🔎

Parameters:

session — the session to use for making this request.
name_or_id — this resource's identifier, if needed by the request. The default is None.
ignore_missing — when set to False, NotFoundException will be raised when the resource does not exist. When set to True, None will be returned when attempting to find a nonexistent resource.
list_base_path — base_path to be used when you need listing resources.
microversion — API version to override the negotiated one.
params — any additional parameters to be passed into underlying methods, such as to existing() in order to pass on URI parameters.

Returns: the Resource object matching the given name or id or None if nothing matches.

Raises openstack.exceptions.DuplicateResource if more than one resource is found for this request.

Raises openstack.exceptions.NotFoundException if nothing is found and ignore_missing is False.

🦋 `openstack.image.v2.member`

💖 The Member Class

The Member class inherits from Resource. 🫶

class openstack.image.v2.member.Member(_synchronized=False,
connection=None, **attrs)

The base resource.

Parameters:

_synchronized — this is not intended to be used directly. See new() and existing().
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.
resources_key = 'members' — plural form of key for resource.
base_path = '/images/%(image_id)s/members' — the base part of the URI for this resource.
allow_create = True — allow create operation for this resource.
allow_fetch = True — allow get operation for this resource.
allow_commit = True — allow update operation for this resource.
allow_delete = True — allow delete operation for this resource.
allow_list = True — allow list operation for this resource.
member_id — the ID of the image member. An image member is a tenant with whom the image is shared. 👯
created_at — the date and time when the member was created.
image_id — image ID stored through the image API. Typically a UUID.
status — the status of the image.
schema — the URL for schema of the member.
updated_at — the date and time when the member was updated.

🌸 `openstack.image.v2.metadef_namespace`

🎀 The MetadefNamespace Class

The MetadefNamespace class inherits from Resource. ✨

class
openstack.image.v2.metadef_namespace.MetadefNamespace(_synchronized=False,
connection=None, **attrs)

The base resource.

Parameters:

_synchronized — this is not intended to be used directly. See new() and existing().
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.
resources_key = 'namespaces' — plural form of key for resource.
base_path = '/metadefs/namespaces' — the base part of the URI for this resource.
allow_create = True — allow create operation for this resource.
allow_fetch = True — allow get operation for this resource.
allow_commit = True — allow update operation for this resource.
allow_list = True — allow list operation for this resource.
allow_delete = True — allow delete operation for this resource.
delete_all_properties(session) — delete all properties in a namespace. 🧹

Parameters

session — the session to use for making this request.

Returns — the server response. 💅

delete_all_objects(session)

Delete all objects in a namespace.

Parameters

session — the session to use for making this request.

Returns — the server response.

add_tag(session, tag)

Adds a single tag to the resource.

Parameters

session — the session to use for making this request.
tag — the tag as a string.

set_tags(session, tags, append=False)

Sets/Replaces all tags on the resource.

Parameters

session — the session to use for making this request.
tags (list) — list with tags to be set on the resource.
append — if set to true, adds new tags to existing tags, else overwrites the existing tags with new ones.

🦋 `openstack.image.v2.metadef_object`

The `MetadefObject` Class

The MetadefObject class inherits from Resource (<#openstack.resource.Resource>). 🫶

class openstack.image.v2.metadef_object.MetadefObject(_synchronized=False, connection=None, **attrs)

The base resource.

Parameters

_synchronized — this is not intended to be used directly. See new() (<#openstack.resource.Resource.new>) and existing() (<#openstack.resource.Resource.existing>).
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.

resources_key = 'objects' — plural form of key for resource.

base_path = '/metadefs/namespaces/%(namespace_name)s/objects' — the base part of the URI for this resource.

allow_create = True — allow create operation for this resource.

allow_fetch = True — allow get operation for this resource.

allow_commit = True — allow update operation for this resource.

allow_delete = True — allow delete operation for this resource.

allow_list = True — allow list operation for this resource.

name — the name of this resource.

🌸 `openstack.image.v2.metadef_property`

The `MetadefProperty` Class

The MetadefProperty class inherits from Resource (<#openstack.resource.Resource>). ✨

class openstack.image.v2.metadef_property.MetadefProperty(_synchronized=False, connection=None, **attrs)

The base resource.

Parameters

_synchronized — this is not intended to be used directly. See new() (<#openstack.resource.Resource.new>) and existing() (<#openstack.resource.Resource.existing>).
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.

base_path = '/metadefs/namespaces/%(namespace_name)s/properties' — the base part of the URI for this resource.

allow_create = True — allow create operation for this resource.

allow_fetch = True — allow get operation for this resource.

allow_commit = True — allow update operation for this resource.

allow_delete = True — allow delete operation for this resource.

allow_list = True — allow list operation for this resource.

namespace_name — an identifier (a name) for the namespace.

name — the name of the property.

type — the property type.

title — the title of the property.

description — detailed description of the property.

operators — a list of operator.

default — default property description.

is_readonly — indicates whether this is a read-only property.

minimum — minimum allowed numerical value.

maximum — maximum allowed numerical value.

enum — enumerated list of property values.

pattern — a regular expression (ECMA 262, http://www.ecma-international.org/publications/standards/Ecma-262.htm) that a string value must match.

min_length — minimum allowed string length.

max_length — maximum allowed string length.

items — schema for the items in an array.

require_unique_items — indicates whether all values in the array must be distinct.

min_items — minimum length of an array.

max_items — maximum length of an array.

allow_additional_items — describes extra items, if you use tuple typing. If the value of items is an array (tuple typing) and the instance is longer than the list of schemas in items, the additional items are described by the schema in this property. If this value is false, the instance cannot be longer than the list of schemas in items. If this value is true, that is equivalent to the empty schema (anything goes).

classmethod list(session, paginated=True, base_path=None, allow_unknown_params=False, *, microversion=None, **params)

This method is a generator which yields resource objects.

A re-implementation of list() (<#openstack.resource.Resource.list>) that handles glance's single, unpaginated list implementation.

Refer to list() (<#openstack.resource.Resource.list>) for full documentation including parameter, exception and return type documentation.

💜 `openstack.image.v2.metadef_resource_type`

The `MetadefResourceType` Class

The MetadefResourceType class inherits from Resource (<#openstack.resource.Resource>). 🔥

class openstack.image.v2.metadef_resource_type.MetadefResourceType(_synchronized=False, connection=None, **attrs)

The base resource.

Parameters

_synchronized — this is not intended to be used directly. See new() (<#openstack.resource.Resource.new>) and existing() (<#openstack.resource.Resource.existing>).
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.

resources_key = 'resource_types' — plural form of key for resource.

base_path = '/metadefs/resource_types' — the base part of the URI for this resource.

allow_list = True — allow list operation for this resource.

name — the name of metadata definition resource type.

created_at — the date and time when the resource type was created.

updated_at — the date and time when the resource type was updated.

The `MetadefResourceTypeAssociation` Class

The MetadefResourceTypeAssociation class inherits from Resource (<#openstack.resource.Resource>). 🎀

class openstack.image.v2.metadef_resource_type.MetadefResourceTypeAssociation(_synchronized=False, connection=None, **attrs)

The base resource.

Parameters

_synchronized — this is not intended to be used directly. See new() (<#openstack.resource.Resource.new>) and existing() (<#openstack.resource.Resource.existing>).
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.

resources_key = 'resource_type_associations' — plural form of key for resource.

base_path = '/metadefs/namespaces/%(namespace_name)s/resource_types' — the base part of the URI for this resource.

allow_create = True — allow create operation for this resource.

allow_delete = True — allow delete operation for this resource.

allow_list = True — allow list operation for this resource.

namespace_name — the name of the namespace whose details you want to see.

name — the name of metadata definition resource type.

created_at — the date and time when the resource type was created.

updated_at — the date and time when the resource type was updated.

prefix — prefix for any properties in the namespace that you want to apply to the resource type. If you specify a prefix, you must append a prefix separator, such as the colon (:) character.

properties_target — some resource types allow more than one key and value pair for each instance. For example, the Image service allows both user and image metadata on volumes. The properties_target parameter enables a namespace target to remove the ambiguity.

🦋 `openstack.image.v2.metadef_schema`

The `MetadefSchema` Class

The MetadefSchema class inherits from Resource (<#openstack.resource.Resource>). 🌈

class openstack.image.v2.metadef_schema.MetadefSchema(_synchronized=False, connection=None, **attrs)

The base resource.

Parameters

_synchronized — bestie do NOT touch this one directly, it's not meant for you 💅 peep new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing> instead.
- connection — a reference to the Connection that's being used. It defaults to None so Resource objects can exist without an active Connection, like in unit tests, no cap. And any self._connection usage in Resource code better guard itself with a None check, fr fr.

base_path = '/schemas/metadefs' — the base part of the URI for this resource. iconic little prefix ✨

allow_fetch = True — allow get operation for this resource. we love a readable resource 🫶

additional_properties — a boolean value that indicates allows users to add custom properties.

definitions — a set of definitions.

required — a list of required resources.

properties — schema properties. yes those are the actual words, it's giving minimalist 🌸

🦋 openstack.image.v2.service_info 🦋

⭐ The Store Class ⭐

The Store class inherits from Resource <#openstack.resource.Resource>. ok lineage slay 👑

class openstack.image.v2.service_info.Store(_synchronized=False,
connection=None, **attrs)

The base resource

Parameters

_synchronized — this is not intended to be used directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.

resources_key = 'stores' — plural form of key for resource. keys but make it plural 💖

base_path = '/info/stores' — the base part of the URI for this resource.

allow_list = True — allow list operation for this resource. lists are literally her whole thing 📋

description — description of the store

is_default — default

properties — (yes, that's the whole description, she said what she said 🙈)

delete_image(session, image, *, ignore_missing=False) — delete image from store

Parameters

session — the session to use for making this request.
image — the value can be either the ID of an image or a Image <#openstack.image.v2.image.Image> instance.

Returns — the result of the delete if resource found, else None.

Raises — NotFoundException <#openstack.exceptions.NotFoundException> when ignore_missing if False and a nonexistent resource is attempted to be deleted. so like, if you set it to False and the thing isn't there, it's gonna yell at you 😭

🎀 The Import Info Class 🎀

The Import class inherits from Resource <#openstack.resource.Resource>.

class openstack.image.v2.service_info.Import(_synchronized=False,
connection=None, **attrs)

The base resource

Parameters

_synchronized — this is not intended to be used directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.

base_path = '/info/import' — the base part of the URI for this resource.

allow_fetch = True — allow get operation for this resource.

import_methods — import methods

💜 openstack.image.v2.task 💜

👑 The Task Class 👑

The Task class inherits from Resource <#openstack.resource.Resource>.

class openstack.image.v2.task.Task(_synchronized=False, connection=None,
**attrs)

The base resource

Parameters

_synchronized — this is not intended to be used directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.

resources_key = 'tasks' — plural form of key for resource.

base_path = '/tasks' — the base part of the URI for this resource.

allow_create = True — allow create operation for this resource.

allow_fetch = True — allow get operation for this resource.

allow_list = True — allow list operation for this resource.

created_at — the date and time when the task was created.

expires_at — the date and time when the task is subject to removal. bye bestie ⏳

input — a JSON object specifying the input parameters to the task.

message — human-readable text, possibly an empty string, usually displayed in an error situation to provide more information about what has occurred.

owner_id — the ID of the owner, or project, of the task.

result — a JSON object specifying the outcome of the task.

schema — the URL for schema of the task.

status — the status of the task.

type — the type of task represented by this content.

updated_at — the date and time when the task was updated.

🌈 KeyManager Resources 🌈

🧚 openstack.key_manager.v1.container 🧚

🌸 The Container Class 🌸

The Container class inherits from Resource <#openstack.resource.Resource>.

class openstack.key_manager.v1.container.Container(_synchronized=False,
connection=None, **attrs)

The base resource

Parameters

_synchronized — this is not intended to be used directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.

resources_key = 'containers' — plural form of key for resource.

base_path = '/containers' — the base part of the URI for this resource.

allow_create = True — allow create operation for this resource.

allow_fetch = True — allow get operation for this resource.

allow_commit = True — allow update operation for this resource.

allow_delete = True — allow delete operation for this resource.

allow_list = True — allow list operation for this resource. she does it all, main character energy ✨

container_ref — a URI for this container

container_id — the ID for this container

created_at — the timestamp when this container was created.

name — the name of this container

secret_refs — a list of references to secrets in this container

status — the status of this container

type — the type of this container

updated_at — the timestamp when this container was updated.

consumers — a party interested in this container.

🍓 openstack.key_manager.v1.container_acl 🍓

💅 The ContainerACL Class 💅

The ContainerACL class inherits from Resource <#openstack.resource.Resource>.

class
openstack.key_manager.v1.container_acl.ContainerACL(_synchronized=False,
connection=None, **attrs)

The base resource

Parameters

_synchronized — this is not intended to be used directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.

base_path = '/containers/%(container_id)s/acl' — the base part of the URI for this resource.

allow_create = True — allow create operation for this resource.

allow_fetch = True — allow get operation for this resource.

allow_commit = True — allow update operation for this resource.

allow_delete = True — allow delete operation for this resource.

allow_list = False — allow list operation for this resource. nope, not this one 🙅‍♀️

create_opts = ... — class-level configuration for the create operation. Subclasses can override this to set per-resource defaults without overriding create(). the full default is literally:

CreateOpts(request_key=<Unset.UNSET: 'UNSET'>,
response_key=<Unset.UNSET: 'UNSET'>, method='PUT',
requires_id=False, response_has_body=True)

commit_method = 'PATCH' — method for committing a resource. This must be PATCH if allow_patch is True. ⚠️ like, for real, it must be 💀

requires_id = False — do calls for this resource require an ID.

container_id — the ID of the container this ACL belongs to

acl_ref — a URI for this container ACL

read — read operation settings, e.g. {'users': [str], 'project-access': bool}.

created_at — the timestamp when this ACL was created (ISO 8601 format)

updated_at — the timestamp when this ACL was last updated (ISO 8601 format)

🌟 openstack.key_manager.v1.order 🌟

🦋 The Order Class 🦋

The Order class inherits from Resource <#openstack.resource.Resource>.

class openstack.key_manager.v1.order.Order(_synchronized=False, connection=None, **attrs)

The base resource 🫶

Parameters

_synchronized — bestie, do NOT pass this directly, it's not for you. See new() and existing() instead, they've got you.
connection — a reference to the Connection being used. It defaults to None so you can make Resource objects without an active Connection, like in unit tests. And heads up: if you're using self._connection inside Resource code, guard it with a None check. No cap.

resources_key = 'orders' — the plural form of the key for this resource.

base_path = '/orders' — the base part of the URI for this resource.

allow_create = True — allow create operation for this resource.

allow_fetch = True — allow get operation for this resource.

allow_commit = True — allow update operation for this resource.

allow_delete = True — allow delete operation for this resource.

allow_list = True — allow list operation for this resource.

created_at — timestamp in ISO8601 format of when the order was created.

creator_id — Keystone Id of the user who created the order.

meta — a dictionary containing key-value parameters which specify the details of an order request.

order_ref — a URI for this order.

order_id — the ID of this order.

secret_ref — secret href associated with the order.

secret_id — secret ID associated with the order.

sub_status — metadata associated with the order.

sub_status_message — metadata associated with the order.

updated_at — timestamp in ISO8601 format of the last time the order was updated.

🌸 `openstack.key_manager.v1.project_quota` — the ProjectQuota Class 🌸

The ProjectQuota class inherits from Resource.

class openstack.key_manager.v1.project_quota.ProjectQuota(_synchronized=False, connection=None, **attrs)

The base resource 💖

Parameters

_synchronized — not intended to be used directly, fr. See new() and existing().
connection — reference to the Connection being used. Defaults to None so Resource objects can exist without an active Connection, like in unit tests. Use of self._connection in Resource code should protect itself with a check for None.

resource_key = 'project_quotas' — singular form of key for resource.

resources_key = 'project_quotas' — plural form of key for resource.

base_path = '/project-quotas' — the base part of the URI for this resource.

allow_create = True — allow create operation for this resource.

allow_fetch = True — allow get operation for this resource.

allow_commit = True — allow update operation for this resource.

allow_delete = True — allow delete operation for this resource.

allow_list = True — allow list operation for this resource.

secrets — contains the configured quota value of the requested project for the secret resource.

orders — contains the configured quota value of the requested project for the orders resource.

containers — contains the configured quota value of the requested project for the containers resource.

consumers — contains the configured quota value of the requested project for the consumers resource.

cas — contains the configured quota value of the requested project for the CAs resource.

🦋 `openstack.key_manager.v1.quota` — the Quota Class 🦋

The Quota class inherits from Resource.

class openstack.key_manager.v1.quota.Quota(_synchronized=False, connection=None, **attrs)

The base resource ✨

Parameters

_synchronized — not intended to be used directly. See new() and existing().
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.

resource_key = 'quotas' — singular form of key for resource.

resources_key = 'quotas' — plural form of key for resource.

base_path = '/quotas' — the base part of the URI for this resource.

allow_fetch = True — allow get operation for this resource.

secrets — contains the effective quota value of the current project for the secret resource.

orders — contains the effective quota value of the current project for the orders resource.

containers — contains the effective quota value of the current project for the containers resource.

consumers — contains the effective quota value of the current project for the consumers resource.

cas — contains the effective quota value of the current project for the CAs resource.

Lowkey note the difference here — project_quota gives you the configured values for the requested project, and quota gives you the effective values for the current project. Two different vibes entirely 💅

👑 `openstack.key_manager.v1.secret` — the Secret Class 👑

The Secret class inherits from Resource.

class openstack.key_manager.v1.secret.Secret(_synchronized=False, connection=None, **attrs)

The base resource 🎀

Parameters

_synchronized — not intended to be used directly. See new() and existing().
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.

resources_key = 'secrets' — plural form of key for resource.

base_path = '/secrets' — the base part of the URI for this resource.

allow_create = True — allow create operation for this resource.

allow_fetch = True — allow get operation for this resource.

allow_commit = True — allow update operation for this resource.

allow_delete = True — allow delete operation for this resource.

allow_list = True — allow list operation for this resource.

algorithm — metadata provided by a user or system for informational purposes.

bit_length — metadata provided by a user or system for informational purposes. Value must be greater than zero, okay? like, non-negotiable.

content_types — a list of content types.

expires_at — once this timestamp has past, the secret will no longer be available. it's giving expiry date, bestie 😭

created_at — timestamp of when the secret was created.

mode — the type/mode of the algorithm associated with the secret information.

name — the name of the secret set by the user.

secret_ref — a URI to the secret.

secret_store_id — computed UUID of the secret store currently holding the payload (microversion 1.3+; JSON null when N/A).

secret_store_ref — computed HREF of the secret store currently holding the payload (microversion 1.3+; JSON null when N/A).

secret_type — used to indicate the type of secret being stored.

status — the status of this secret.

updated_at — a timestamp when this secret was updated.

payload — the secret's data to be stored. payload_content_type must also be supplied if payload is included. (optional)

payload_content_type — the media type for the content of the payload. (required if payload is included)

payload_content_encoding — the encoding used for the payload to be able to include it in the JSON request. Currently only base64 is supported. (required if payload is encoded)

🫶 the payload trio is a package deal — include payload without payload_content_type and it's a bad time. include an encoded payload without payload_content_encoding and, again, bad time.

`fetch` — the glow-up method ✨

fetch(session, requires_id=True, base_path=None, error_message=None, skip_cache=False, *, resource_response_key=None, microversion=None, **params)

Get a remote resource based on this instance. literally what it says on the tin.

Parameters

session — the session to use for making this request.
requires_id — whether resource ID should be part of the requested URI.
base_path — base part of the URI for fetching resources, if different from base_path.
error_message — an error message to be returned if requested object does not exist.
skip_cache — a boolean indicating whether optional API cache should be skipped for this invocation.
resource_response_key — overrides the usage of self.resource_key when processing the response body.
microversion — API version to override the negotiated one.
params — additional parameters that can be consumed.

🍓 heads up on the signature: everything after that lone * is keyword-only, so resource_response_key and microversion have to be passed by name. no sneaky positional business, iykyk.

Returns — this Resource instance, bestie. Like, the whole thing. 💅

Raises MethodNotSupported (<#openstack.exceptions.MethodNotSupported>) if Resource.allow_fetch is not set to True.

Raises NotFoundException (<#openstack.exceptions.NotFoundException>) if the resource literally was not found. gone. missing. 😭

`migrate_store(session, secret_store_id, *, microversion=None)`

Okay so this one migrates your secret onto a different secret store. Moving houses but for secrets 🚚✨

It requires key-manager microversion 1.3. But lowkey, prefer migrate_secret_store() instead — that one actually enforces the microversion and accepts UUID/URI/SecretStore. iykyk 🫶

Parameters

session — the session you're using to make this request.
secret_store_id — destination store UUID (or, plot twist, the trailing path segment of a …/secret-stores/<uuid> URI).
microversion — the API microversion to use. Defaults to the negotiated microversion for this resource.

Returns — None. That's it. Nothing to show off. 🤷‍♀️

🎀 `openstack.key_manager.v1.secret_acl` 🎀

The `SecretACL` Class

The SecretACL class inherits from Resource (<#openstack.resource.Resource>). iconic behaviour honestly 👑

class openstack.key_manager.v1.secret_acl.SecretACL(_synchronized=False, connection=None, **attrs)

The base resource.

Parameters

_synchronized — this is not intended to be used directly, bestie. See new() (<#openstack.resource.Resource.new>) and existing() (<#openstack.resource.Resource.existing>).
connection — reference to the Connection being used. Defaults to None so Resource objects can be used without an active Connection, like in unit tests. And if you're using self._connection in Resource code, protect yourself with a check for None. fr fr, protect yourself. 🫶

Attributes

base_path = '/secrets/%(secret_id)s/acl' — the base part of the URI for this resource.
allow_create = False — allow create operation for this resource. nope, not today.
allow_fetch = True — allow get operation for this resource. yes queen.
allow_commit = True — allow update operation for this resource. slay.
allow_delete = True — allow delete operation for this resource. bye bestie 💀
allow_list = False — allow list operation for this resource. no listing.
requires_id = False — do calls for this resource require an ID? apparently not.
secret_id — the UUID of the parent secret used in the URL.
read — ACL definition for read operations (dict).
acl_ref — reference URL returned by PUT/PATCH.

🦋 `openstack.key_manager.v1.secret_consumer` 🦋

The `SecretConsumer` Class

class openstack.key_manager.v1.secret_consumer.SecretConsumer(_synchronized=False, connection=None, **attrs)

Bases: Resource (<#openstack.resource.Resource>)

The base resource.

Parameters

_synchronized — this is not intended to be used directly. See new() (<#openstack.resource.Resource.new>) and existing() (<#openstack.resource.Resource.existing>).
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.

Attributes

resources_key = 'consumers' — plural form of key for resource. cute.
base_path = '/secrets/%(secret_id)s/consumers' — the base part of the URI for this resource.
allow_create = True — allow create operation for this resource. ✨
allow_delete = True — allow delete operation for this resource.
allow_list = True — allow list operation for this resource. we love a listable queen.
requires_id = False — do calls for this resource require an ID? no ma'am.
secret_id — URI attributes.
service — body attributes.
resource_type — body attributes.
resource_id — body attributes.

🌸 `openstack.key_manager.v1.secret_store` 🌸

The `SecretStore` Class

The SecretStore class inherits from Resource (<#openstack.resource.Resource>). 💜

class openstack.key_manager.v1.secret_store.SecretStore(_synchronized=False, connection=None, **attrs)

The base resource.

Parameters

_synchronized — this is not intended to be used directly. See new() (<#openstack.resource.Resource.new>) and existing() (<#openstack.resource.Resource.existing>).
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.

Attributes

resources_key = 'secret_stores' — plural form of key for resource.
base_path = '/secret-stores' — the base part of the URI for this resource.
allow_create = False — allow create operation for this resource.
allow_fetch = True — allow get operation for this resource.
allow_commit = False — allow update operation for this resource.
allow_delete = False — allow delete operation for this resource.
allow_list = True — allow list operation for this resource. 🎀
name — the name of the secret store.
status — the status of the secret store.
created_at — timestamp of when the secret store was created.
updated_at — timestamp of when the secret store was last updated.
secret_store_ref — a URI to the secret store.
secret_store_id — the ID of the secret store (from secret_store_ref href, or the explicit secret_store_id field on microversion 1.3+).
global_default — flag indicating if this secret store is global default.
crypto_plugin — the crypto plugin name.
secret_store_plugin — the secret store plugin name.

🌈 Load Balancer Resources 🌈

💅 `openstack.load_balancer.v2.amphora` 💅

The `Amphora` Class

The Amphora class inherits from Resource (<#openstack.resource.Resource>). amphora is such a fun word honestly, say it out loud. amphora. 🏺

class openstack.load_balancer.v2.amphora.Amphora(_synchronized=False, connection=None, **attrs)

The base resource.

Parameters

_synchronized — this is not intended to be used directly. See new() (<#openstack.resource.Resource.new>) and existing() (<#openstack.resource.Resource.existing>).
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.

Attributes

resource_key = 'amphora' — singular form of key for resource.
resources_key = 'amphorae' — plural form of key for resource. yes, amphorae. latin ate. 🏛️
base_path = '/octavia/amphorae' — the base part of the URI for this resource.
allow_create = False — allow create operation for this resource.
allow_fetch = True — allow get operation for this resource.
allow_commit = False — allow update operation for this resource.
allow_delete = False — allow delete operation for this resource.
allow_list = True — allow list operation for this resource.

Fields, bestie 🫶

id — the ID of the amphora.
loadbalancer_id — the ID of the load balancer.
compute_id — the ID of the amphora resource in the compute system.
lb_network_ip — the management IP of the amphora.
vrrp_ip — the address of the vrrp port on the amphora.
ha_ip — the IP address of the Virtual IP (VIP).
vrrp_port_id — the vrrp port's ID in the networking system.
ha_port_id — the ID of the Virtual IP (VIP) port.
cert_expiration — the date the certificate for the amphora expires.
cert_busy — whether the certificate is in the process of being replaced.
role — the role configured for the amphora. One of STANDALONE, MASTER, BACKUP.
status — the status of the amphora. One of: BOOTING, ALLOCATED, READY, PENDING_CREATE, PENDING_DELETE, DELETED, ERROR.
vrrp_interface — the bound interface name of the vrrp port on the amphora.
vrrp_id — the vrrp group's ID for the amphora.
vrrp_priority — the priority of the amphora in the vrrp group.
cached_zone — the availability zone of a compute instance, cached at create time.
created_at — the UTC date and timestamp when the resource was created.
updated_at — the UTC date and timestamp when the resource was last updated.
image_id — the ID of the glance image used for the amphora.
compute_flavor — the ID of the compute flavor used for the amphora.

`configure(session)`

Configure load balancer. 🎛️

Update the amphora agent configuration. This will push the new configuration to the amphora agent and will update the configuration options that are mutatable.

Parameters

session — the session to use for making this request.

Returns — None.

`failover(session)`

Failover load balancer. iykyk, it's giving dramatic exit but make it infrastructure 💀

Parameters

session — the session to use for making this request.

Returns — None.

🌸 The AmphoraConfig Class 🌸

Okay so the AmphoraConfig class inherits from Resource <#openstack.resource.Resource> — yep, that's the base class, she's the parent, we love her.

class openstack.load_balancer.v2.amphora.AmphoraConfig(_synchronized=False,
connection=None, **attrs)

It's the base resource 💅

Parameters

_synchronized — bestie do NOT use this directly, like fr. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing> instead.
connection — a reference to the Connection being used. Defaults to None so that Resource objects can be used without an active Connection, like in unit tests. And listen — any use of self._connection in Resource code should protect itself with a check for None. Protect yourself, queen 🫶

Attributes, in order, no skipping:

base_path = '/octavia/amphorae/%(amphora_id)s/config' — the base part of the URI for this resource 🎀
allow_create = False — nope, no create operation for this resource
allow_fetch = False — no get operation either, sorry
allow_commit = True — oh THIS one's a yes, update operation allowed
allow_delete = False — no delete operation
allow_list = False — and no list operation
allow_empty_commit = True — commits happen without the header or body being dirty. Iconic, low maintenance
requires_id = False — do calls for this resource require an ID? No ma'am
amphora_id — the ID of the amphora 🍓

`commit(session, prepend_key=True, has_body=False, *args, **kwargs)`

Commit the state of the instance to the remote resource. Slay, go off, update the world ✨

Parameters

session — the session to use for making this request
prepend_key — whether the resource_key <#openstack.resource.Resource.resource_key> should be prepended in a resource creation request. Defaults to True
retry_on_conflict — whether to enable retries on HTTP CONFLICT (409). A value of None leaves the Adapter defaults alone 🙈
base_path — base part of the URI for modifying resources, if it's different from base_path <#openstack.resource.Resource.base_path>
microversion — API version to override the negotiated one
attrs — attributes to pass when updating the resource. These should correspond to either Body or Header values on the resource

Returns

This Resource instance 💖

Raises

MethodNotSupported <#openstack.exceptions.MethodNotSupported> if Resource.allow_commit is not set to True. So like, don't even try it.

🦋 The AmphoraFailover Class 🦋

The AmphoraFailover class inherits from Resource <#openstack.resource.Resource>. Same base resource energy, different path, we move 🧚

class openstack.load_balancer.v2.amphora.AmphoraFailover(_synchronized=False,
connection=None, **attrs)

It's the base resource 💅

Parameters

_synchronized — not intended to be used directly, bestie. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None

Attributes:

base_path = '/octavia/amphorae/%(amphora_id)s/failover' — the base part of the URI for this resource
allow_create = False — allow create operation for this resource
allow_fetch = False — allow get operation for this resource
allow_commit = True — allow update operation for this resource
allow_delete = False — allow delete operation for this resource
allow_list = False — allow list operation for this resource
allow_empty_commit = True — commits happen without header or body being dirty
requires_id = False — do calls for this resource require an ID
amphora_id — the ID of the amphora

`commit(session, prepend_key=True, has_body=False, *args, **kwargs)`

Commit the state of the instance to the remote resource.

Parameters

session — the session to use for making this request
prepend_key — whether the resource_key <#openstack.resource.Resource.resource_key> should be prepended in a resource creation request. Default to True
retry_on_conflict — whether to enable retries on HTTP CONFLICT (409). Value of None leaves the Adapter defaults
base_path — base part of the URI for modifying resources, if different from base_path <#openstack.resource.Resource.base_path>
microversion — API version to override the negotiated one
attrs — attributes to pass when updating the resource. These should correspond to either Body or Header values on the resource

Returns

This Resource instance.

Raises

MethodNotSupported <#openstack.exceptions.MethodNotSupported> if Resource.allow_commit is not set to True.

🎀 `openstack.load_balancer.v2.availability_zone` 🎀

The AvailabilityZone Class

The AvailabilityZone class inherits from Resource <#openstack.resource.Resource> — she's got range, look at all those Trues ⭐

class openstack.load_balancer.v2.availability_zone.AvailabilityZone(_synchronized=False,
connection=None, **attrs)

It's the base resource 💅

Parameters

_synchronized — not intended to be used directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None

Attributes:

resource_key = 'availability_zone' — singular form of key for resource
resources_key = 'availability_zones' — plural form of key for resource
base_path = '/lbaas/availabilityzones' — the base part of the URI for this resource
allow_create = True — allow create operation for this resource ✅
allow_fetch = True — allow get operation for this resource ✅
allow_commit = True — allow update operation for this resource ✅
allow_delete = True — allow delete operation for this resource ✅
allow_list = True — allow list operation for this resource ✅
name — the name of the availability zone
description — the availability zone description
availability_zone_profile_id — the associated availability zone profile ID
is_enabled — whether the availability zone is enabled for use or not

🌈 `openstack.load_balancer.v2.availability_zone_profile` 🌈

The AvailabilityZoneProfile Class

The AvailabilityZoneProfile class inherits from Resource <#openstack.resource.Resource>. Another full-access icon, we love to see it 👑

class openstack.load_balancer.v2.availability_zone_profile.AvailabilityZoneProfile(_synchronized=False,
connection=None, **attrs)

It's the base resource 💅

Parameters

_synchronized — not intended to be used directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None

Attributes:

resource_key = 'availability_zone_profile' — singular form of key for resource
resources_key = 'availability_zone_profiles' — plural form of key for resource
base_path = '/lbaas/availabilityzoneprofiles' — the base part of the URI for this resource
allow_create = True — allow create operation for this resource
allow_fetch = True — allow get operation for this resource
allow_commit = True — allow update operation for this resource
allow_delete = True — allow delete operation for this resource
allow_list = True — allow list operation for this resource
id — the ID of the availability zone profile
name — the name of the availability zone profile
provider_name — the provider this availability zone profile is for
availability_zone_data — the JSON string containing the availability zone metadata. It's giving raw JSON realness, handle with care 🫶

🐚 `openstack.load_balancer.v2.flavor` 🐚

The Flavor Class

The Flavor class inherits from Resource <#openstack.resource.Resource>. Yes, a load balancer flavor is a whole thing, and yes she's valid 💅

class openstack.load_balancer.v2.flavor.Flavor(_synchronized=False,
connection=None, **attrs)

It's the base resource

Parameters

_synchronized — this is not intended to be used directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>
connection — your lil pointer to the Connection in play. It defaults to None so you can totally build Resource objects without a live connection (unit tests say hi 👋). Heads up: if you're using self._connection inside Resource code, guard it with a None check, okay?
resource_key = 'flavor' — the singular key for this resource ✨
resources_key = 'flavors' — the plural key for this resource ✨
base_path = '/lbaas/flavors' — the base chunk of the URI for this resource 🛣️
allow_create = True — green light for create, bestie 💚
allow_fetch = True — green light for get 🫶
allow_commit = True — green light for update ✍️
allow_delete = True — green light for delete 🗑️
allow_list = True — green light for list 📋
id — the ID of the flavor 🆔
name — the name of the flavor 🏷️
description — the flavor description, iykyk 📝
flavor_profile_id — the associated flavor profile ID 🔗
is_enabled — whether the flavor is enabled for use or not (yes/no energy) ✅

openstack.load_balancer.v2.flavor_profile

The FlavorProfile Class

okay so the FlavorProfile class inherits from Resource <#openstack.resource.Resource> — iconic inheritance moment 💅

class openstack.load_balancer.v2.flavor_profile.FlavorProfile(_synchronized=False, connection=None, **attrs)

The base resource — literally the blueprint 🧚

Parameters

_synchronized — not meant to be used directly, bestie. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing> 🙈
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, like in unit tests. Use of self._connection in Resource code should protect itself with a check for None.
resource_key = 'flavorprofile' — the singular key for this resource 🌸
resources_key = 'flavorprofiles' — the plural key for this resource 🌸
base_path = '/lbaas/flavorprofiles' — the base part of the URI for this resource 🛣️
allow_create = True — create? allowed, obviously 💖
allow_fetch = True — get? allowed 🫶
allow_commit = True — update? allowed ✍️
allow_delete = True — delete? allowed 🗑️
allow_list = True — list? allowed 📋
id — the ID of the flavor profile 🆔
name — the name of the flavor profile 🏷️
provider_name — the provider this flavor profile is for 🏢
flavor_data — the JSON string containing the flavor metadata 🧾

openstack.load_balancer.v2.health_monitor

The HealthMonitor Class

HealthMonitor inherits from Resource <#openstack.resource.Resource> — it's giving "watching you breathe" energy 👀

class openstack.load_balancer.v2.health_monitor.HealthMonitor(_synchronized=False, connection=None, **attrs)

The base resource 🧚

Parameters

_synchronized — not intended to be used directly, fr. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.
resource_key = 'healthmonitor' — the singular key for this resource 💜
resources_key = 'healthmonitors' — the plural key for this resource 💜
base_path = '/lbaas/healthmonitors' — the base part of the URI for this resource 🛣️
allow_create = True — create is a yes 💚
allow_list = True — list is a yes 📋
allow_fetch = True — get is a yes 🫶
allow_delete = True — delete is a yes 🗑️
allow_commit = True — update is a yes ✍️

not me pointing out that allow_list sits before allow_fetch here — that's the original order, keep it, no cap 💀

created_at — properties timestamp when the health monitor was created ⏰
delay — the time, in seconds, between sending probes to members ⏱️
expected_codes — the expected http status codes to get from a successful health check 🎯
http_method — the HTTP method that the monitor uses for requests 📮
is_admin_state_up — the administrative state of the health monitor. Type: bool 🔛
max_retries — the number of successful checks before changing the operating status of the member to ONLINE 🔁
max_retries_down — the number of allowed check failures before changing the operating status of the member to ERROR 💀
name — the health monitor name 🏷️
operating_status — operating status of the member 📊
pools — list of associated pools. Type: list of dicts which contain the pool IDs 🏊
pool_id — the ID of the associated Pool 🔗
project_id — the ID of the project 🆔
provisioning_status — the provisioning status of this member ⚙️
timeout — the time, in seconds, after which a health check times out ⌛
type — the type of health monitor 🧬
updated_at — timestamp when the member was last updated 🔄
url_path — the HTTP path of the request to test the health of a member 🛤️

openstack.load_balancer.v2.l7_policy

The L7Policy Class

L7Policy inherits from Resource <#openstack.resource.Resource> — layer 7 decisions, main character energy 👑

class openstack.load_balancer.v2.l7_policy.L7Policy(_synchronized=False, connection=None, **attrs)

The base resource 🧚

Parameters

_synchronized — not intended to be used directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing> 🙈
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.
resource_key = 'l7policy' — the singular key for this resource 🎀
resources_key = 'l7policies' — the plural key for this resource 🎀
base_path = '/lbaas/l7policies' — the base part of the URI for this resource 🛣️
allow_create = True — create: slay ✅
allow_list = True — list: slay 📋
allow_fetch = True — get: slay 🫶
allow_commit = True — update: slay ✍️
allow_delete = True — delete: slay 🗑️

and yeah, the order is create, list, fetch, commit, delete in this one — different from the others, that's just how it is, periodt 💅

action — properties the action to be taken when l7policy is matched 🎬
created_at — timestamp when the L7 policy was created ⏰
description — the l7policy description 📝
is_admin_state_up — the administrative state of the l7policy. Type: bool 🔛
listener_id — the ID of the listener associated with this l7policy 🎧
name — the l7policy name 🏷️
operating_status — operating status of the member 📊
position — sequence number of this l7policy 🔢
project_id — the ID of the project this l7policy is associated with 🆔
provisioning_status — the provisioning status of this l7policy ⚙️
redirect_pool_id — the ID of the pool to which the requests will be redirected 🏊
redirect_prefix — the URL prefix to which the requests should be redirected 🔀
redirect_url — the URL to which the requests should be redirected 🔗
rules — the list of L7Rules associated with the l7policy 📜
updated_at — timestamp when the member was last updated 🔄

openstack.load_balancer.v2.l7_rule

The L7Rule Class

L7Rule inherits from Resource <#openstack.resource.Resource> — the little rule that could, bestie 🦋

class openstack.load_balancer.v2.l7_rule.L7Rule(_synchronized=False, connection=None, **attrs)

The base resource 🧚

Parameters

_synchronized — not intended to be used directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.
resource_key = 'rule' — the singular key for this resource ⭐
resources_key = 'rules' — the plural key for this resource ⭐
base_path = '/lbaas/l7policies/%(l7policy_id)s/rules' — the base part of the URI for this resource. note the %(l7policy_id)s substitution — it's nested inside a policy, iykyk 🪆
allow_create = True — create? yes 💚
allow_list = True — list? yes 📋
allow_fetch = True — get? yes 🫶
allow_commit = True — update? yes ✍️
allow_delete = True — delete? yes 🗑️
is_admin_state_up — properties the administrative state of the l7policy. Type: bool 🔛
compare_type — the comparison type that gets used with the value in this L7 rule 🎯
created_at — timestamp of when this L7 rule was created ⏰
key — the key to use for the comparison 🔑
l7_policy_id — the ID of the l7 policy it's attached to 🫶
operating_status — the operating status of this l7rule 💫
project_id — the ID of the project this l7policy is associated with 🏷️
provisioning_status — the provisioning status of this l7policy 📦
type — the type of L7 rule ✨
updated_at — timestamp of when this L7 rule was last updated 🔄
rule_value — the value to be compared against ⚖️

🎧 `openstack.load_balancer.v2.listener`

The Listener Class 💖

so this one inherits from Resource (peep openstack.resource.Resource, it's the blueprint of the whole fam):

class openstack.load_balancer.v2.listener.Listener(_synchronized=False, connection=None, **attrs)

The base resource — that's the whole vibe of it, no cap.

Parameters

_synchronized — not a thing you should touch directly, bestie 🙈 see new() and existing() instead.
connection — a reference to the Connection in use. Defaults to None so Resource objects can exist without an active Connection (think unit tests, etc.). Anything in Resource code reaching for self._connection should protect itself with a check for None — like, be responsible pls 🫡

Class attributes, coming right up:

resource_key = 'listener' — the singular form of the key for this resource.
resources_key = 'listeners' — the plural form of the key for this resource.
base_path = '/lbaas/listeners' — the base part of the URI for this resource.
allow_create = True — creation is allowed, slay.
allow_fetch = True — fetching is allowed.
allow_commit = True — updating is allowed.
allow_delete = True — deleting is allowed.
allow_list = True — listing is allowed.

And the fields themselves:

allowed_cidrs — a list of IPv4 or IPv6 CIDRs.
alpn_protocols — a list of ALPN protocols.
connection_limit — the max number of connections permitted for this load balancer. Default is infinite ♾️
created_at — timestamp of when the listener was created.
default_pool — the default pool that requests get routed to.
default_pool_id — the ID of the default pool. It must have a compatible protocol with the listener, so don't be messy about it 😭
default_tls_container_ref — a reference to a container of TLS secrets 🔐
description — a description for the listener.
is_hsts_include_subdomains — defines whether the include_subdomains directive is used for HSTS or not.
hsts_max_age — enables HTTP Strict Transport Security (HSTS) and sets the max_age directive to the given value.
is_hsts_preload — defines whether the hsts_preload directive is used for HSTS or not.
insert_headers — a dictionary of additional headers to insert into the HTTP header.
is_admin_state_up — the administrative state of the listener: up True or down False. Type: bool.
l7_policies — a list of l7policies associated with this listener.
load_balancer_id — the ID of the parent load balancer.
load_balancers — a list of load balancers associated with this listener. Type: list of dicts which contain the load balancer IDs.
name — the listener's name ✨
operating_status — the operating status of the listener.
project_id — the ID of the project this listener is associated with.
protocol — the protocol of the listener, which is TCP, HTTP, HTTPS or TERMINATED_HTTPS.
protocol_port — the port the listener listens on, e.g. 80.
provisioning_status — the provisioning status of this listener.
sni_container_refs — a list of references to TLS secrets. Type: list.
updated_at — timestamp of when the listener was last updated.
timeout_client_data — frontend client inactivity timeout, in milliseconds.
timeout_member_connect — backend member connection timeout, in milliseconds.
timeout_member_data — backend member inactivity timeout, in milliseconds.
timeout_tcp_inspect — time, in milliseconds, to wait for additional TCP packets so it can inspect the content 👀
tls_ciphers — stores a cipher string in OpenSSL format.
tls_versions — a list of TLS protocols to be used by the listener.

The ListenerStats Class 📊

yep, this one also inherits from Resource (openstack.resource.Resource), keeping the family tradition alive:

class openstack.load_balancer.v2.listener.ListenerStats(_synchronized=False, connection=None, **attrs)

The base resource — periodt.

Parameters

_synchronized — do not use this directly, bestie 🙅‍♀️ see new() and existing().
connection — a reference to the Connection in use. Defaults to None so Resource objects can be used without an active Connection, like in unit tests. Code using self._connection should always guard against None.

Class attributes:

resource_key = 'stats' — singular form of the key for this resource.
base_path = '/lbaas/listeners/%(listener_id)s/stats' — the base part of the URI for this resource.
allow_create = False — nope, no creating stats, they're not yours to invent 💀
allow_fetch = True — fetching? yes.
allow_commit = False — no updating either.
allow_delete = False — and definitely no deleting.
allow_list = False — no listing. it's giving read-only-for-one 💅

Fields:

listener_id — the ID of the listener.
active_connections — the currently active connections.
bytes_in — the total bytes received.
bytes_out — the total bytes sent.
request_errors — the total requests that were unable to be fulfilled 😭
total_connections — the total connections handled.

🛜 `openstack.load_balancer.v2.load_balancer`

The LoadBalancer Class 👑

the big one. inherits from Resource (openstack.resource.Resource), as everything does:

class openstack.load_balancer.v2.load_balancer.LoadBalancer(_synchronized=False, connection=None, **attrs)

The base resource — main character energy tbh.

Parameters

_synchronized — not intended for direct use, friend 🙈 see new() and existing().
connection — a reference to the Connection being used. Defaults to None so Resource objects can exist without an active Connection, e.g. in unit tests. Any self._connection usage in Resource code should protect itself with a check for None.

Class attributes:

resource_key = 'loadbalancer' — singular form of the key for this resource.
resources_key = 'loadbalancers' — plural form of the key for this resource.
base_path = '/lbaas/loadbalancers' — the base part of the URI for this resource.
allow_create = True — create: yes.
allow_fetch = True — fetch: yes.
allow_commit = True — update: yes.
allow_delete = True — delete: yes.
allow_list = True — list: yes. we love a fully-enabled resource 🌈

Fields:

is_admin_state_up — the administrative state of the load balancer. Type: bool.
availability_zone — the name of the target Octavia availability zone.
created_at — timestamp of when the load balancer was created.
description — the load balancer description.
flavor_id — the load balancer flavor ID.
listeners — a list of listeners associated with this load balancer.
name — the load balancer's name ✨
operating_status — the operating status of the load balancer.
pools — a list of pools associated with this load balancer.
project_id — the ID of the project this load balancer is associated with.
provider — the provider name for the load balancer.
provisioning_status — the provisioning status of this load balancer.
updated_at — timestamp of when the load balancer was last updated.
vip_address — the VIP address of the load balancer.
vip_network_id — the VIP network ID (the docs spell it "netowrk" and honestly? iconic, we're leaving it 🫶).
vip_port_id — the VIP port ID.
vip_subnet_id — the VIP subnet ID.
vip_sg_ids — a list of security group IDs for the VIP port.
additional_vips — additional VIPs. yes, more of them 🎀

Methods:

failover(session) — failover the load balancer.

Parameters

session — the session to use for making this request.

Returns

None

The LoadBalancerStats Class 📈

inherits from Resource (openstack.resource.Resource), because of course it does:

class openstack.load_balancer.v2.load_balancer.LoadBalancerStats(_synchronized=False, connection=None, **attrs)

The base resource — same energy as ever.

Parameters

_synchronized — ngl bestie, don't touch this one directly 🙈 it's internal. Peep new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing> instead.
- connection — a reference to the Connection in use. Defaults to None so Resource objects can exist without an active Connection (think unit tests, vibes only). Any self._connection use inside Resource code should guard itself with a None check, fr fr.

resource_key = 'stats' — the singular form of the key for this resource.

base_path = '/lbaas/loadbalancers/%(lb_id)s/stats' — the base part of the URI for this resource.

allow_create = False — create operation? Not allowed, sorry bestie.

allow_fetch = True — get operation is a yes 💅

allow_commit = False — update? nope.

allow_delete = False — delete? also nope.

allow_list = False — list? absolutely not.

lb_id — the ID of the load balancer. iconic identifier behavior.

active_connections — the currently active connections.

bytes_in — the total bytes received.

bytes_out — the total bytes sent.

request_errors — the total requests that were unable to be fulfilled. 😭

total_connections — the total connections handled.

💅 The LoadBalancerFailover Class

The LoadBalancerFailover class inherits from Resource <#openstack.resource.Resource>. slay.

openstack.load_balancer.v2.load_balancer.LoadBalancerFailover(_synchronized=False,
connection=None, **attrs)

The base resource ✨

Parameters

_synchronized — not meant for direct use, bestie. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
connection — reference to the Connection being used. Defaults to None so Resource objects work without an active Connection, like in unit tests. Any use of self._connection in Resource code should protect itself with a check for None. 🫶

base_path = '/lbaas/loadbalancers/%(lb_id)s/failover' — the base part of the URI for this resource.

allow_create = False — create operation not allowed.

allow_fetch = False — get operation, also no.

allow_commit = True — update operation is allowed! we love a commit 💅

allow_delete = False — delete operation not allowed.

allow_list = False — list operation not allowed.

allow_empty_commit = True — commits happen without the header or body being dirty. no notes.

requires_id = False — do calls for this resource require an ID? nope, false.

lb_id — the ID of the load balancer.

commit(session, prepend_key=True, has_body=False, *args, **kwargs) — commit the state of the instance to the remote resource. let's go ✨

Parameters

session — the session to use for making this request.
prepend_key — whether the resource_key <#openstack.resource.Resource.resource_key> should be prepended in a resource creation request. Defaults to True.
retry_on_conflict — whether to enable retries on HTTP CONFLICT (409). A value of None leaves the Adapter defaults. 🙈
base_path — base part of the URI for modifying resources, if it's different from base_path <#openstack.resource.Resource.base_path>.
microversion — API version to override the negotiated one.
attrs — attributes to pass when updating the resource. These should correspond to either Body or Header values on the resource.

Returns This Resource instance. 💖

Raises MethodNotSupported <#openstack.exceptions.MethodNotSupported> if Resource.allow_commit is not set to True. periodt.

🌸 openstack.load_balancer.v2.member

The Member Class

The Member class inherits from Resource <#openstack.resource.Resource>. bestie she's giving full CRUD energy.

openstack.load_balancer.v2.member.Member(_synchronized=False,
connection=None, **attrs)

The base resource ✨

Parameters

_synchronized — this is not intended to be used directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.

resource_key = 'member' — singular form of key for resource.

resources_key = 'members' — plural form of key for resource.

base_path = '/lbaas/pools/%(pool_id)s/members' — the base part of the URI for this resource.

allow_create = True — create operation allowed 💅

allow_fetch = True — get operation allowed.

allow_commit = True — update operation allowed.

allow_delete = True — delete operation allowed.

allow_list = True — list operation allowed. full set, we ate.

address — the IP address of the member.

created_at — timestamp when the member was created.

is_admin_state_up — the administrative state of the member, which is up True or down False. Type: bool.

monitor_address — IP address used to monitor this member.

monitor_port — port used to monitor this member.

name — name of the member.

operating_status — operating status of the member.

pool_id — the ID of the owning pool.

provisioning_status — the provisioning status of this member.

project_id — the ID of the project this member is associated with.

protocol_port — the port on which the application is hosted.

subnet_id — subnet ID in which to access this member.

updated_at — timestamp when the member was last updated.

weight — a positive integer value that indicates the relative portion of traffic that this member should receive from the pool. For example, a member with a weight of 10 receives five times as much traffic as a member with weight of 2. math queen 🧮

backup — a bool value that indicates whether the member is a backup or not. Backup members only receive traffic when all non-backup members are down. lowkey the emergency contact of the pool.

🦋 openstack.load_balancer.v2.pool

The Pool Class

The Pool class inherits from Resource <#openstack.resource.Resource>. main character energy, honestly.

openstack.load_balancer.v2.pool.Pool(_synchronized=False,
connection=None, **attrs)

The base resource ✨

Parameters

_synchronized — not intended to be used directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
connection — reference to the Connection being used. Defaults to None so Resource objects can be used without an active Connection, like in unit tests. Use of self._connection in Resource code should protect itself with a check for None.

resource_key = 'pool' — singular form of key for resource.

resources_key = 'pools' — plural form of key for resource.

base_path = '/lbaas/pools' — the base part of the URI for this resource.

allow_create = True — create operation allowed.

allow_list = True — list operation allowed.

allow_fetch = True — get operation allowed.

allow_delete = True — delete operation allowed.

allow_commit = True — update operation allowed.

alpn_protocols — properties List of ALPN protocols.

created_at — timestamp when the pool was created.

description — description for the pool.

health_monitor_id — Health Monitor ID.

is_admin_state_up — the administrative state of the pool. Type: bool.

lb_algorithm — the loadbalancing algorithm used in the pool.

listener_id — ID of listener associated with this pool.

listeners — list of listeners associated with this pool.

loadbalancer_id — ID of load balancer associated with this pool.

loadbalancers — list of loadbalancers associated with this pool.

members — members associated with this pool.

name — the pool name.

operating_status — operating status of the pool.

project_id — the ID of the project.

protocol — the protocol of the pool.

provisioning_status — provisioning status of the pool.

tls_ciphers — stores a string of cipher strings in OpenSSL format.

session_persistence — a JSON object specifying the session persistence for the pool.

tls_versions — a list of TLS protocol versions to be used in by the pool.

updated_at — timestamp of when the pool got its last glow-up ✨
tls_enabled — do we TLS the connections to the backend member servers? Type: bool
ca_tls_container_ref — holds the CA certificate that the backend servers use 🔐
crl_container_ref — holds the revocation list file

🦋 `openstack.load_balancer.v2.provider` 🦋

The Provider Class

ok so the Provider class inherits from Resource <#openstack.resource.Resource> — that's the family tree, no cap 🌳

class openstack.load_balancer.v2.provider.Provider(_synchronized=False, connection=None, **attrs)

The base resource

Parameters

_synchronized — this is not meant to be used directly, bestie. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing> instead 💅
connection — a reference to the Connection being used. Defaults to None so that Resource objects can be used without an active Connection, like in unit tests. Any use of self._connection in Resource code should protect itself with a check for None. 🫶
resources_key = 'providers' — plural form of the key for this resource.
base_path = '/lbaas/providers' — the base part of the URI for this resource.
allow_create = False — allow create operation for this resource. (nope, not happening 🙈)
allow_fetch = False — allow get operation for this resource.
allow_commit = False — allow update operation for this resource.
allow_delete = False — allow delete operation for this resource.
allow_list = True — allow list operation for this resource. this one slays ✨
name — the provider name.
description — the provider description.

The Provider Flavor Capabilities Class

and ProviderFlavorCapabilities also inherits from Resource <#openstack.resource.Resource> 🧚

class openstack.load_balancer.v2.provider.ProviderFlavorCapabilities(_synchronized=False, connection=None, **attrs)

The base resource

Parameters

_synchronized — not meant to be used directly, fr fr. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
connection — reference to the Connection being used. Defaults to None so Resource objects work without an active Connection, like in unit tests. Use of self._connection in Resource code should protect itself with a check for None.
resources_key = 'flavor_capabilities' — plural form of the key for this resource.
base_path = '/lbaas/providers/%(provider)s/flavor_capabilities' — the base part of the URI for this resource.
allow_create = False — allow create operation for this resource.
allow_fetch = False — allow get operation for this resource.
allow_commit = False — allow update operation for this resource.
allow_delete = False — allow delete operation for this resource.
allow_list = True — allow list operation for this resource. 👑
provider — the provider name to query.
name — the provider name.
description — the provider description.

🌈 `openstack.load_balancer.v2.quota` 🌈

The Quota Class

Quota inherits from Resource <#openstack.resource.Resource> — the whole quota situation lives here 💖

class openstack.load_balancer.v2.quota.Quota(_synchronized=False, connection=None, **attrs)

The base resource

Parameters

_synchronized — do not use this directly, bestie. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.
resource_key = 'quota' — singular form of the key for this resource.
resources_key = 'quotas' — plural form of the key for this resource.
base_path = '/lbaas/quotas' — the base part of the URI for this resource.
allow_fetch = True — allow get operation for this resource.
allow_commit = True — allow update operation for this resource.
allow_delete = True — allow delete operation for this resource.
allow_list = True — allow list operation for this resource.
load_balancers — the maximum amount of load balancers you can have. Type: int
listeners — the maximum amount of listeners you can create. Type: int
pools — the maximum amount of pools you can create. Type: int
health_monitors — the maximum amount of health monitors you can create. Type: int
members — the maximum amount of members you can create. Type: int
project_id — the ID of the project this quota is associated with.

🧚 Network Resources 🧚

`openstack.network.v2.address_group`

The AddressGroup Class

AddressGroup inherits from Resource <#openstack.resource.Resource>. it's giving "address group extension" energy 🌸

class openstack.network.v2.address_group.AddressGroup(_synchronized=False, connection=None, **attrs)

Address group extension.

The base resource

Parameters

_synchronized — not intended to be used directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.
resource_key = 'address_group' — singular form of the key for this resource.
resources_key = 'address_groups' — plural form of the key for this resource.
base_path = '/address-groups' — the base part of the URI for this resource.
allow_create = True — allow create operation for this resource.
allow_fetch = True — allow get operation for this resource.
allow_commit = True — allow update operation for this resource.
allow_delete = True — allow delete operation for this resource.
allow_list = True — allow list operation for this resource.
id — the ID of the address group.
name — the address group name.
description — the address group name. (yes, it literally says that in the docs, i'm not making this up 😭)
project_id — the ID of the project that owns the address group.
tenant_id — Tenant_id (deprecated attribute). ⚠️ deprecated, so maybe don't build your whole personality on it.
addresses — the IP addresses of the address group.
add_addresses(session, addresses) — add addresses into the address group.

Parameters

session (Adapter) — the session to communicate through.
addresses (list) — the list of address strings.

Returns the response as a AddressGroup object with updated addresses

Raises SDKException <#openstack.exceptions.SDKException> on error.

remove_addresses(session, addresses) — remove addresses from the address group.

Parameters

session (Adapter) — the session to communicate through.
addresses (list) — the list of address strings.

Returns the response as a AddressGroup object with updated addresses

Raises SDKException <#openstack.exceptions.SDKException> on error.

`openstack.network.v2.address_scope`

The AddressScope Class

AddressScope inherits from Resource <#openstack.resource.Resource>. address scope extension, let's go 🎀

class openstack.network.v2.address_scope.AddressScope(_synchronized=False, connection=None, **attrs)

Address scope extension.

The base resource

Parameters

_synchronized — this is not intended to be used directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.
resource_key = 'address_scope' — singular form of the key for this resource.
resources_key = 'address_scopes' — plural form of the key for this resource.
base_path = '/address-scopes' — the base part of the URI for this resource.
allow_create = True — allow create operation for this resource.
allow_fetch = True — allow get operation for this resource.
allow_commit = True — allow update operation for this resource.
allow_delete = True — allow delete operation for this resource.
allow_list = True — allow list operation for this resource. 💅
name — the address scope name.
project_id — the ID of the project that owns the address scope.
tenant_id — Tenant_id (deprecated attribute). ⚠️ same deal, deprecated!
ip_version — the IP address family of the address scope. Type: int
is_shared — indicates whether this address scope is shared across all projects. Type: bool

🌈 `openstack.network.v2.agent`

💖 The Agent Class

Okay so the Agent class inherits from Resource <#openstack.resource.Resource>, bestie. It's giving very much "base class energy."

class openstack.network.v2.agent.Agent(_synchronized=False,
connection=None, **attrs)

Neutron agent extension. Slay. And underneath it all it's literally just the base resource.

Parameters — the whole squad of args:

_synchronized — ngl you are not supposed to touch this directly. Peep new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing> instead. 💅
connection — a reference to the Connection being used. Defaults to None so that Resource objects can vibe without an active Connection, like in unit tests. Any use of self._connection in Resource code should protect itself with a check for None. 🫶

Class attributes, go off:

resource_key = 'agent' — singular form of key for resource. ✨
resources_key = 'agents' — plural form of key for resource.
base_path = '/agents' — the base part of the URI for this resource.
allow_create = False — allow create operation for this resource. (Not today, bestie.)
allow_fetch = True — allow get operation for this resource. 👑
allow_commit = True — allow update operation for this resource.
allow_delete = True — allow delete operation for this resource.
allow_list = True — allow list operation for this resource.

Instance attributes, the main characters:

agent_type — the type of network agent.
availability_zone — availability zone for the network agent.
binary — the name of the network agent's application binary. 🔥
configuration — network agent configuration data specific to the agent_type.
created_at — timestamp when the network agent was created. 🎀
description — the network agent description.
last_heartbeat_at — timestamp when the network agent's heartbeat was last seen. 💓
host — the host the agent is running on.
is_admin_state_up — the administrative state of the network agent, which is up True or down False. Type: bool. 🦋
is_alive — whether or not the network agent is alive. Type: bool.
resources_synced — whether or not the agent is successfully synced towards placement (the docs spell it "succesffully" and honestly? iconic of them). Agents supporting the guaranteed minimum bandwidth feature share their resource view with neutron-server, and neutron-server shares this view with placement; resources_synced represents the success of the latter. The value None means no resource view synchronization to Placement was attempted. true / false values signify the success of the last synchronization attempt. Type: bool. 🧚
started_at — timestamp when the network agent was last started.
topic — the messaging queue topic the network agent subscribes to. 💬
ha_state — the HA state of the L3 agent. This is one of 'active', 'standby' or 'fault' for HA routers, or None for other types of routers.
ha_chassis_priority — the HA chassis priority for this agent in the router's HA_Chassis_Group (OVN). Higher values indicate higher priority; the highest priority chassis is the active gateway. None for non-OVN backends. Type: int. 👑

🫶 `get_bgp_speakers_hosted_by_dragent(session)`

List BGP speakers hosted by a Dynamic Routing Agent. Periodt.

Parameters:

session (Adapter) — the session to communicate through.

Returns: a list of BgpSpeakers.

Return type: BgpSpeaker <#openstack.network.v2.bgp_speaker.BgpSpeaker>

🦋 `openstack.network.v2.auto_allocated_topology`

The Auto Allocated Topology Class

The Auto Allocated Topology class inherits from Resource <#openstack.resource.Resource>. (Original docs say "Toplogy" — we love a typo queen.) 💀

class
openstack.network.v2.auto_allocated_topology.AutoAllocatedTopology(_synchronized=False,
connection=None, **attrs)

The base resource. That's the whole vibe.

Parameters:

_synchronized — this is not intended to be used directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>. 💅
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.

Class attributes:

resource_key = 'auto_allocated_topology' — singular form of key for resource. ✨
base_path = '/auto-allocated-topology' — the base part of the URI for this resource.
allow_create = False — allow create operation for this resource.
allow_fetch = True — allow get operation for this resource. 🔥
allow_commit = False — allow update operation for this resource.
allow_delete = True — allow delete operation for this resource.
allow_list = False — allow list operation for this resource.

Instance attributes:

project_id — Project ID. If project is not specified the topology will be created for the project the user is authenticated against. Will return in error if resources have not been configured correctly. To use this feature auto-allocated-topology, subnet_allocation, external-net and router extensions must be enabled and set up. 🎀
tenant_id — Tenant_id (deprecated attribute). 😭 Deprecated, so like... don't.

🌸 `openstack.network.v2.availability_zone`

The AvailabilityZone Class

The AvailabilityZone class inherits from Resource <#openstack.resource.Resource>.

class
openstack.network.v2.availability_zone.AvailabilityZone(_synchronized=False,
connection=None, **attrs)

The base resource, as always bestie.

Parameters:

_synchronized — not intended to be used directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>. 😌
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.

Class attributes:

resource_key = 'availability_zone' — singular form of key for resource.
resources_key = 'availability_zones' — plural form of key for resource.
base_path = '/availability_zones' — the base part of the URI for this resource.
allow_create = False — allow create operation for this resource.
allow_fetch = False — allow get operation for this resource.
allow_commit = False — allow update operation for this resource.
allow_delete = False — allow delete operation for this resource.
allow_list = True — allow list operation for this resource. She only lists, and honestly? Same. 💅

Instance attributes:

name — name of the availability zone.
resource — type of resource for the availability zone, such as network.
state — state of the availability zone, either available or unavailable. ⭐

💜 `openstack.network.v2.bgp_peer`

The BgpPeer Class

The BgpPeer class inherits from Resource <#openstack.resource.Resource>. Peers gonna peer. 🫶

class openstack.network.v2.bgp_peer.BgpPeer(_synchronized=False,
connection=None, **attrs)

The base resource.

Parameters:

_synchronized — not intended to be used directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>. ✨
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.

Class attributes:

resource_key = 'bgp_peer' — singular form of key for resource.
resources_key = 'bgp_peers' — plural form of key for resource.
base_path = '/bgp-peers' — the base part of the URI for this resource.
allow_create = True — allow create operation for this resource. 🔥
allow_fetch = True — allow get operation for this resource.
allow_commit = True — allow update operation for this resource.
allow_delete = True — allow delete operation for this resource.
allow_list = True — allow list operation for this resource. Full menu, no cap. 👑

Instance attributes:

id — the Id of the BGP Peer.
name — the BGP Peer's name.
project_id — the ID of the project that owns the BGP Peer.
tenant_id — Tenant_id (deprecated attribute). 🙈
auth_type — the authentication type for the BGP Peer, can be none or md5. none by default.
remote_as — the remote Autonomous System number of the BGP Peer.
peer_ip — the ip address of the Peer. 🦋

🎀 `openstack.network.v2.bgp_speaker`

The BgpSpeaker Class

The BgpSpeaker class inherits from Resource <#openstack.resource.Resource>. Speaker of the house, literally.

class openstack.network.v2.bgp_speaker.BgpSpeaker(_synchronized=False,
connection=None, **attrs)

The base resource.

Parameters:

_synchronized — this is not intended to be used directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>. 💅
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect
connection — reference to the Connection being used. Defaults to None so Resource objects can be used without an active Connection, like in unit tests. If you use self._connection in Resource code, protect it with a check for None. 🫶

Class-level keys, bestie — these are the ones doing the heavy lifting ✨:

resource_key = 'bgp_speaker' — singular form of key for resource.
resources_key = 'bgp_speakers' — plural form of key for resource.
base_path = '/bgp-speakers' — the base part of the URI for this resource.
allow_create = True — allow create operation for this resource.
allow_fetch = True — allow get operation for this resource.
allow_commit = True — allow update operation for this resource.
allow_delete = True — allow delete operation for this resource.
allow_list = True — allow list operation for this resource.

And the attrs, slay 💅:

id — the Id of the BGP Speaker.
name — the BGP speaker's name.
project_id — the ID of the project that owns the BGP Speaker.
tenant_id — Tenant_id (deprecated attribute).
ip_version — the IP version (4 or 6) of the BGP Speaker.
advertise_floating_ip_host_routes — whether to enable or disable the advertisement of floating ip host routes by the BGP Speaker. True by default.
advertise_tenant_networks — whether to enable or disable the advertisement of tenant network routes by the BGP Speaker. True by default.
local_as — the local Autonomous System number of the BGP Speaker.
networks — a list of network IDs to which the BGP Speaker is associated.

Methods time, no cap 🔥:

add_bgp_peer(session, peer_id) — add BGP Peer to a BGP Speaker.
- Parameters:
  - session (Adapter) — the session to communicate through.
  - peer_id — id of the peer to associate with the speaker.
- Returns: a dictionary as the API Reference describes it.
- Raises: SDKException <#openstack.exceptions.SDKException> on error.
remove_bgp_peer(session, peer_id) — remove BGP Peer from a BGP Speaker.
- Parameters:
  - session (Adapter) — the session to communicate through.
  - peer_id — the ID of the peer to disassociate from the speaker.
- Raises: SDKException <#openstack.exceptions.SDKException> on error.
add_gateway_network(session, network_id) — add Network to a BGP Speaker.
- Param session: The session to communicate through.
- Parameters:
  - network_id — the ID of the network to associate with the speaker.
- Returns: a dictionary as the API Reference describes it.
remove_gateway_network(session, network_id) — delete Network from a BGP Speaker.
- Parameters:
  - session (Adapter) — the session to communicate through.
  - network_id — the ID of the network to disassociate from the speaker.
get_advertised_routes(session) — list routes advertised by a BGP Speaker.
- Parameters: session (Adapter) — the session to communicate through.
- Returns: the response as a list of routes (cidr/nexthop pair advertised by the BGP Speaker.
- Raises: SDKException <#openstack.exceptions.SDKException> on error.
get_bgp_dragents(session) — list Dynamic Routing Agents hosting a specific BGP Speaker.
- Parameters: session (Adapter) — the session to communicate through.
- Returns: the response as a list of dragents hosting a specific BGP Speaker.
- Return type: Agent <#openstack.network.v2.agent.Agent>
- Raises: SDKException <#openstack.exceptions.SDKException> on error.
add_bgp_speaker_to_dragent(session, bgp_agent_id) — add BGP Speaker to a Dynamic Routing Agent.
- Parameters:
  - session (Adapter) — the session to communicate through.
  - bgp_agent_id — the id of the dynamic routing agent to which add the speaker.
remove_bgp_speaker_from_dragent(session, bgp_agent_id) — delete BGP Speaker from a Dynamic Routing Agent.
- Parameters:
  - session (Adapter) — the session to communicate through.
  - bgp_agent_id — the id of the dynamic routing agent from which remove the speaker.

🌈 `openstack.network.v2.bgpvpn` 🌈

👑 The BgpVpn Class 👑

The BgpVpn class inherits from Resource <#openstack.resource.Resource>.

class openstack.network.v2.bgpvpn.BgpVpn(_synchronized=False,
       connection=None, **attrs)

The base resource 🫶

Parameters:
- _synchronized — this is not intended to be used directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
- connection — reference to the Connection being used. Defaults to None so Resource objects can be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.

Class-level keys, iconic behavior ✨:

resource_key = 'bgpvpn' — singular form of key for resource.
resources_key = 'bgpvpns' — plural form of key for resource.
base_path = '/bgpvpn/bgpvpns' — the base part of the URI for this resource.
allow_create = True — allow create operation for this resource.
allow_fetch = True — allow get operation for this resource.
allow_commit = True — allow update operation for this resource.
allow_delete = True — allow delete operation for this resource.
allow_list = True — allow list operation for this resource.

Attrs, bestie 💖:

id — the Id of the BGPVPN.
name — the BGPVPN's name.
project_id — the ID of the project that owns the BGPVPN.
tenant_id — Tenant_id (deprecated attribute).
route_distinguishers — list of route distinguisher strings.
route_targets — Route Targets that will be both imported and used for export.
import_targets — additional Route Targets that will be imported.
export_targets — additional Route Targets that will be used for export.
local_pref — the default BGP LOCAL_PREF of routes that will be advertised to the BGPVPN.
vni — the globally-assigned VXLAN vni for the BGP VPN.
type — selection of the type of VPN and the technology behind it. Allowed values are l2 or l3.

🦋 `openstack.network.v2.bgpvpn_network_association` 🦋

✨ The BgpVpnNetworkAssociation Class ✨

The BgpVpnNetworkAssociation class inherits from Resource <#openstack.resource.Resource>.

class
openstack.network.v2.bgpvpn_network_association.BgpVpnNetworkAssociation(_synchronized=False,
       connection=None, **attrs)

The base resource 🎀

Parameters:
- _synchronized — this is not intended to be used directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
- connection — reference to the Connection being used. Defaults to None so Resource objects can be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.

Class-level keys, periodt 💅:

resource_key = 'network_association' — singular form of key for resource.
resources_key = 'network_associations' — plural form of key for resource.
base_path = '/bgpvpn/bgpvpns/%(bgpvpn_id)s/network_associations' — the base part of the URI for this resource.
allow_create = True — allow create operation for this resource.
allow_fetch = True — allow get operation for this resource.
allow_commit = False — allow update operation for this resource.
allow_delete = True — allow delete operation for this resource.
allow_list = True — allow list operation for this resource.

Attrs, lowkey essential 🌸:

id — the Id of the BGPVPN.
bgpvpn_id — the ID of the BGPVPN who owns Network Association.
project_id — the ID of the project that owns the BGPVPN.
tenant_id — Tenant_id (deprecated attribute).
network_id — the ID of a Neutron network with which to associate the BGP VPN.

🎀 `openstack.network.v2.bgpvpn_port_association` 🎀

💜 The BgpVpnPortAssociation Class 💜

The BgpVpnPortAssociation class inherits from Resource <#openstack.resource.Resource>.

class
openstack.network.v2.bgpvpn_port_association.BgpVpnPortAssociation(_synchronized=False,
       connection=None, **attrs)

The base resource 🧚

Parameters:
- _synchronized — this is not intended to be used directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
- connection — reference to the Connection being used. Defaults to None so Resource objects can be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.
connection — a reference to the Connection that's being used. It defaults to None so you can still use Resource objects when there's no live connection (unit tests, bestie, we've all been there). Real talk: any use of self._connection inside Resource code has to guard itself with a None check. 💅
resource_key = 'port_association' — the singular key for this resource.
resources_key = 'port_associations' — the plural key for this resource.
base_path = '/bgpvpn/bgpvpns/%(bgpvpn_id)s/port_associations' — the base chunk of the URI for this resource.
allow_create = True — yes, you can create with this one.
allow_fetch = True — yes, you can get it.
allow_commit = True — yes, updates are allowed.
allow_delete = True — yes, deletion's on the menu.
allow_list = True — and yes, you can list them too. full package, no notes ✨
id — the Id of the BGPVPN.
bgpvpn_id — the ID of the BGPVPN that owns the Network Association.
project_id — the ID of the project that owns the BGPVPN.
tenant_id — tenant_id, which is a deprecated attribute, jsyk.
port_id — the ID of a Neutron Port you're associating the BGP VPN with.
advertise_fixed_ips — a boolean flag that controls whether the fixed IPs of a port get advertised to the BGPVPN (default: true).
routes — a list of routes, where each route is a dict with at least a type key, and that key can be prefix or bgpvpn. For the prefix type, the IP prefix (v4 or v6) you want to advertise goes in the prefix key. For the bgpvpn type, the bgpvpn_id key says which BGPVPN to readvertise routes from.

🌈 `openstack.network.v2.bgpvpn_router_association`

The `BgpVpnRouterAssociation` Class 🎀

Okay so the BgpVpnRouterAssociation class inherits from Resource <#openstack.resource.Resource>. iconic behaviour, honestly.

class openstack.network.v2.bgpvpn_router_association.BgpVpnRouterAssociation(_synchronized=False, connection=None, **attrs)

This is the base resource, bestie.

Parameters 🫶

_synchronized — not meant for direct use, okay? Go look at new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing> instead.
connection — a reference to the Connection that's being used. Defaults to None so Resource objects work without an active connection, like in unit tests. And fr, any self._connection usage in Resource code should protect itself with a None check.
resource_key = 'router_association' — the singular key for this resource.
resources_key = 'router_associations' — the plural key for this resource.
base_path = '/bgpvpn/bgpvpns/%(bgpvpn_id)s/router_associations' — the base part of the URI for this resource.
allow_create = True — creation? allowed.
allow_fetch = True — fetching? allowed.
allow_commit = True — committing updates? allowed.
allow_delete = True — deleting? allowed.
allow_list = True — listing? allowed. we love a resource that does it all 💖
id — the Id of the BGPVPN.
bgpvpn_id — the ID of the BGPVPN that owns the Network Association.
project_id — the ID of the project that owns the BGPVPN.
tenant_id — tenant_id, a deprecated attribute.
router_id — the ID of a Neutron router you're associating the BGP VPN with.
advertise_extra_routes — a boolean flag controlling whether the routes listed in the routes attribute of the router get advertised to the BGPVPN (default: true).

🦋 `openstack.network.v2.extension`

The `Extension` Class ✨

The Extension class inherits from Resource <#openstack.resource.Resource>. slay.

class openstack.network.v2.extension.Extension(_synchronized=False, connection=None, **attrs)

The base resource, obviously.

Parameters 💜

_synchronized — nope, not for direct use. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
connection — reference to the Connection in use. Defaults to None so Resource objects can exist without an active connection, like in unit tests. Any self._connection usage in Resource code must protect itself with a None check.
resource_key = 'extension' — singular key for the resource.
resources_key = 'extensions' — plural key for the resource.
base_path = '/extensions' — the base part of the URI for this resource.
allow_fetch = True — get operation allowed. (No create/commit/delete here, just so we're clear 👀)
allow_list = True — list operation allowed.
alias — an alias the extension is known under.
description — text describing what the extension actually does.
links — links pertaining to this extension.
name — the name of this extension.
updated_at — timestamp of when the extension was last updated.

🍓 `openstack.network.v2.flavor`

The `Flavor` Class 🌸

The Flavor class inherits from Resource <#openstack.resource.Resource>.

class openstack.network.v2.flavor.Flavor(_synchronized=False, connection=None, **attrs)

The base resource.

Parameters 🎀

_synchronized — not intended for direct use, bestie. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
connection — reference to the Connection being used. Defaults to None so Resource objects work without an active connection, like in unit tests. Uses of self._connection in Resource code should protect themselves with a None check.
resource_key = 'flavor' — singular key for this resource.
resources_key = 'flavors' — plural key for this resource.
base_path = '/flavors' — the base part of the URI for this resource.
allow_create = True — creation allowed.
allow_fetch = True — get allowed.
allow_commit = True — update allowed.
allow_delete = True — delete allowed.
allow_list = True — list allowed. all the green checks, we stan 🌈
description — the description for the flavor.
is_enabled — sets the enabled flag.
name — the name of the flavor.
service_type — the service type this flavor applies to.
service_profile_ids — IDs of the service profiles associated with this flavor.

💀 `openstack.network.v2.floating_ip`

The `FloatingIP` Class 🧚

The FloatingIP class inherits from Resource <#openstack.resource.Resource>.

class openstack.network.v2.floating_ip.FloatingIP(_synchronized=False, connection=None, **attrs)

The base resource, as ever.

Parameters 🔥

_synchronized — please don't use this directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
connection — reference to the Connection being used. Defaults to None so Resource objects can be used without an active connection, like in unit tests. Any self._connection use in Resource code should guard itself with a None check.
resource_key = 'floatingip' — singular key for this resource.
resources_key = 'floatingips' — plural key for this resource.
base_path = '/floatingips' — the base part of the URI for this resource.
allow_create = True — create: allowed.
allow_fetch = True — fetch: allowed.
allow_commit = True — commit: allowed.
allow_delete = True — delete: allowed.
allow_list = True — list: allowed.
created_at — timestamp of when the floating IP was created.
description — the floating IP's description.
dns_domain — the DNS domain.
dns_name — the DNS name.
fixed_ip_address — the fixed IP address associated with the floating IP. Heads up: if you're planning to associate the floating IP with a fixed IP at creation time, you must indicate the identifier of the internal port. And if that internal port has multiple associated IP addresses, the service just picks the first one — unless you explicitly pass the fixed_ip_address parameter to choose a specific IP. so specific, love that for you 💅
floating_ip_address — the floating IP address.
name — plot twist: the Floating IP object doesn't have a name attribute, so the IP address gets set as the name, letting a user find a floating IP by UUID or IP address using find_ip. workaround queen 👑
floating_network_id — the ID of the network associated with the floating IP.
port_details — read-only. The details of the port this floating IP associates with. Only present if the fip-port-details extension is loaded. Type: a dict with keys name, network_id, mac_address, admin_state_up, status, device_id, device_owner.
port_id — the port ID.
qos_policy_id — the ID of the QoS policy that's attached to the floating IP 💅
project_id — the ID of the project this floating IP is associated with
tenant_id — Tenant_id (deprecated attribute) ⚠️ like, it's still there, but it's giving legacy vibes
router_id — the ID of an associated router
status — the floating IP status. Value is ACTIVE or DOWN
updated_at — timestamp at which the floating IP was last updated
subnet_id — the Subnet ID associated with the floating IP

🫶 `openstack.network.v2.health_monitor`

The HealthMonitor Class ✨

Okay so the HealthMonitor class inherits from Resource <#openstack.resource.Resource> 🧚

class openstack.network.v2.health_monitor.HealthMonitor(_synchronized=False, connection=None, **attrs)

The base resource 🎀

Parameters

_synchronized — this is not intended to be used directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing> 👀
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None 💖
resource_key = 'healthmonitor' — singular form of key for resource
resources_key = 'healthmonitors' — plural form of key for resource
base_path = '/lbaas/healthmonitors' — the base part of the URI for this resource
allow_create = True — allow create operation for this resource
allow_fetch = True — allow get operation for this resource
allow_commit = True — allow update operation for this resource
allow_delete = True — allow delete operation for this resource
allow_list = True — allow list operation for this resource
delay — the time, in seconds, between sending probes to members ⏱️
expected_codes — expected HTTP codes for a passing HTTP(S) monitor
http_method — the HTTP method that the monitor uses for requests
is_admin_state_up — the administrative state of the health monitor, which is up True or down False. Type: bool
max_retries — maximum consecutive health probe tries
name — name of the health monitor
pool_ids — list of pools associated with this health monitor. Type: list of dicts which contain the pool IDs
pool_id — the ID of the pool associated with this health monitor
project_id — the ID of the project this health monitor is associated with
tenant_id — Tenant_id (deprecated attribute) ⚠️
timeout — the maximum number of seconds for a monitor to wait for a connection to be established before it times out. This value must be less than the delay value 🚨
type — the type of probe sent by the load balancer to verify the member state, which is PING, TCP, HTTP, or HTTPS
url_path — path portion of URI that will be probed if type is HTTP(S)

🦋 `openstack.network.v2.listener`

The Listener Class ✨

The Listener class inherits from Resource <#openstack.resource.Resource> 🧚

class openstack.network.v2.listener.Listener(_synchronized=False, connection=None, **attrs)

The base resource 🎀

Parameters

_synchronized — this is not intended to be used directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing> 👀
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None 💖
resource_key = 'listener' — singular form of key for resource
resources_key = 'listeners' — plural form of key for resource
base_path = '/lbaas/listeners' — the base part of the URI for this resource
allow_create = True — allow create operation for this resource
allow_fetch = True — allow get operation for this resource
allow_commit = True — allow update operation for this resource
allow_delete = True — allow delete operation for this resource
allow_list = True — allow list operation for this resource
connection_limit — the maximum number of connections permitted for this load balancer. Default is infinite ♾️
default_pool_id — ID of default pool. Must have compatible protocol with listener 🔥
default_tls_container_ref — a reference to a container of TLS secrets 🔐
description — description for the listener
is_admin_state_up — the administrative state of the listener, which is up True or down False. Type: bool
load_balancer_ids — list of load balancers associated with this listener. Type: list of dicts which contain the load balancer IDs
load_balancer_id — the ID of the load balancer associated with this listener
name — name of the listener
project_id — the ID of the project this listener is associated with
protocol — the protocol of the listener, which is TCP, HTTP, HTTPS or TERMINATED_HTTPS
protocol_port — port the listener will listen to, e.g. 80
sni_container_refs — a list of references to TLS secrets. Type: list

🌈 `openstack.network.v2.load_balancer`

The LoadBalancer Class ✨

The LoadBalancer class inherits from Resource <#openstack.resource.Resource> 🧚

class openstack.network.v2.load_balancer.LoadBalancer(_synchronized=False, connection=None, **attrs)

The base resource 🎀

Parameters

_synchronized — this is not intended to be used directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing> 👀
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None 💖
resource_key = 'loadbalancer' — singular form of key for resource
resources_key = 'loadbalancers' — plural form of key for resource
base_path = '/lbaas/loadbalancers' — the base part of the URI for this resource
allow_create = True — allow create operation for this resource
allow_fetch = True — allow get operation for this resource
allow_commit = True — allow update operation for this resource
allow_delete = True — allow delete operation for this resource
allow_list = True — allow list operation for this resource
description — description for the load balancer
is_admin_state_up — the administrative state of the load balancer, which is up True or down False. Type: bool
listener_ids — list of listeners associated with this load balancer. Type: list of dicts which contain the listener IDs
name — name of the load balancer 👑
operating_status — status of load_balancer operating, e.g. ONLINE, OFFLINE
pool_ids — list of pools associated with this load balancer. Type: list of dicts which contain the pool IDs
project_id — the ID of the project this load balancer is associated with
tenant_id — Tenant_id (deprecated attribute) ⚠️
provider — the name of the provider
provisioning_status — status of load balancer provisioning, e.g. ACTIVE, INACTIVE
vip_address — the IP address of the VIP 💅
vip_port_id — the ID of the port for the VIP
vip_subnet_id — the ID of the subnet on which to allocate the VIP address

⭐ `openstack.network.v2.local_ip`

The LocalIP Class ✨

The LocalIP class inherits from Resource <#openstack.resource.Resource> 🧚

class openstack.network.v2.local_ip.LocalIP(_synchronized=False, connection=None, **attrs)

Local IP extension. 🎀

The base resource 🫶

Parameters

_synchronized — this is not intended to be used directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing> 👀
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None 💖
resource_key = 'local_ip' — singular form of key for resource
resources_key = 'local_ips' — plural form of key for resource
base_path = '/local_ips' — the base part of the URI for this resource
allow_create = True — allow create operation for this resource
allow_fetch = True — allow get operation for this resource
allow_commit = True — allow update operation for this resource
allow_delete = True — allow delete operation for this resource
allow_list = True — allow list operation for this resource 🌸
created_at — the timestamp of when this floating IP got made ✨
description — the local ip's lil description 🎀
id — the ID of the local ip, bestie
ip_mode — the local ip's ip-mode 💅
local_ip_address — the Local IP address, literally
local_port_id — the ID of the port that owns the local ip 🫶
name — the local ip name, iconic
network_id — the ID of the network that owns the local ip 🌸
project_id — the ID of the project that owns the local ip 💖
revision_number — the local ip revision number, no cap
updated_at — the timestamp of when this floating IP was last updated ⭐

openstack.network.v2.local_ip_association

The LocalIPAssociation Class

Okay so the LocalIPAssociation class inherits from Resource <#openstack.resource.Resource> — yes, that's the base resource vibe 💫.

class openstack.network.v2.local_ip_association.LocalIPAssociation(_synchronized=False, connection=None, **attrs)

It's the Local IP extension, periodt.

The base resource

Parameters

_synchronized — bestie, this is not meant to be used directly 🙈. Go look at new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing> instead.
connection — a reference to the Connection that's being used. It defaults to None so Resource objects can be used without an active Connection (like in unit tests, yk). Any use of self._connection in Resource code should protect itself with a None check. 💅
resource_key = 'port_association' — the singular form of the key for this resource 🌈
resources_key = 'port_associations' — the plural form of the key for this resource ✨
base_path = '/local_ips/%(local_ip_id)s/port_associations' — the base part of the URI for this resource 🔥
allow_create = True — green light for the create operation on this resource
allow_fetch = True — green light for the get operation on this resource
allow_commit = True — green light for the update operation on this resource
allow_delete = True — green light for the delete operation on this resource
allow_list = True — green light for the list operation on this resource 👑
fixed_port_id — the fixed port ID 🦋
fixed_ip — the fixed IP, simple as that
host — the Host 🍓
local_ip_address — the local ip address 💜
local_ip_id — the ID of the Local IP address, slay

openstack.network.v2.metering_label

The MeteringLabel Class

And the MeteringLabel class inherits from Resource <#openstack.resource.Resource> too, obvi 💖.

class openstack.network.v2.metering_label.MeteringLabel(_synchronized=False, connection=None, **attrs)

The base resource

Parameters

_synchronized — nope, not for direct use 🙈. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
connection — reference to the Connection in use. Defaults to None so Resource objects work without an active Connection (unit tests, yk). Code using self._connection should guard against None. 💅
resource_key = 'metering_label' — the singular form of the key for this resource 🌸
resources_key = 'metering_labels' — the plural form of the key for this resource ⭐
base_path = '/metering/metering-labels' — the base part of the URI for this resource 🎀
allow_create = True — create operation allowed, go off
allow_fetch = True — get operation allowed
allow_commit = True — update operation allowed
allow_delete = True — delete operation allowed
allow_list = True — list operation allowed, periodt
description — the description of the metering label ✨
name — the name of the metering label 💫
project_id — the ID of the project this metering label is associated with 🫶
tenant_id — Tenant_id (heads up: this is a deprecated attribute 💀)
is_shared — tells you whether this label is shared across all projects. Type: bool 👑

openstack.network.v2.metering_label_rule

The MeteringLabelRule Class

MeteringLabelRule also inherits from Resource <#openstack.resource.Resource>, as one does 🌈.

class openstack.network.v2.metering_label_rule.MeteringLabelRule(_synchronized=False, connection=None, **attrs)

The base resource

Parameters

_synchronized — do not use this directly, bestie 🙈. Check new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
connection — reference to the Connection being used. Defaults to None so Resource objects can exist without an active Connection (unit tests vibe). self._connection users should protect against None. 💅
resource_key = 'metering_label_rule' — the singular form of the key for this resource 💖
resources_key = 'metering_label_rules' — the plural form of the key for this resource 🦋
base_path = '/metering/metering-label-rules' — the base part of the URI for this resource 🌸
allow_create = True — create operation allowed
allow_fetch = True — get operation allowed
allow_commit = True — update operation allowed
allow_delete = True — delete operation allowed
allow_list = True — list operation allowed 💅
direction — ingress or egress: the direction in which the metering label rule is applied. Default: "ingress" 🧚
is_excluded — specifies whether the remote_ip_prefix will be excluded from the traffic counters of the metering label, ie: so you don't count the traffic of a specific IP address of a range. Default: False, Type: bool 🔥
metering_label_id — the metering label ID to associate with this metering label rule 💜
project_id — the ID of the project this metering label rule is associated with 🎀
tenant_id — Tenant_id (heads up: deprecated attribute 💀)
remote_ip_prefix — the remote IP prefix to be associated with this metering label rule ⭐
source_ip_prefix — the source IP prefix to be associated with this metering label rule 🌈
destination_ip_prefix — the destination IP prefix to be associated with this metering label rule 👑

openstack.network.v2.ndp_proxy

The NDPProxy Class

The NDPProxy class inherits from Resource <#openstack.resource.Resource> because that's the family tree 💫.

class openstack.network.v2.ndp_proxy.NDPProxy(_synchronized=False, connection=None, **attrs)

The base resource

Parameters

_synchronized — not intended for direct use 🙈. Peep new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
connection — reference to the Connection being used. Defaults to None so Resource objects can be used without an active Connection, like in unit tests. Any self._connection usage in Resource code should check for None. 💅
resource_key = 'ndp_proxy' — the singular form of the key for this resource ✨
resources_key = 'ndp_proxies' — the plural form of the key for this resource 🌸
base_path = '/ndp_proxies' — the base part of the URI for this resource 🎀
allow_create = True — create operation allowed
allow_fetch = True — get operation allowed
allow_commit = True — update operation allowed
allow_delete = True — delete operation allowed
allow_list = True — list operation allowed, iykyk
created_at — the timestamp of when the NDP proxy was created 🌟
description — the description 💅
id — the ID of the NDP proxy
ip_address — the internal IP address 🦋
name — the name of this resource 🍓
port_id — the ID of internal port 💜
project_id — the ID of the project that owns the NDP proxy 🌈
revision_number — the NDP proxy revision number
router_id — the ID of Router 👑
updated_at — the timestamp of when the NDP proxy was last updated ⭐

openstack.network.v2.network

The Network Class

And here's the big one: the Network class inherits from Resource <#openstack.resource.Resource> 💖.

class openstack.network.v2.network.Network(_synchronized=False, connection=None, **attrs)

The base resource

Parameters

_synchronized — again, not for direct use, bestie 🙈. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
connection — reference to the Connection being used. Defaults to None so Resource objects can be used without an active Connection, e.g. in unit tests. Use of self._connection in Resource code should protect itself with a None check. 💅
resource_key = 'network' — the singular form of the key for this resource ✨
resources_key = 'networks' — the plural form of the key for this resource 🌸
base_path = '/networks' — the base part of the URI for this resource 🎀
allow_create = True — create operation allowed for this resource
allow_fetch = True — green light for the get operation on this resource 🫶
allow_commit = True — green light for the update operation on this resource ✨
allow_delete = True — green light for the delete operation on this resource 💅
allow_list = True — green light for the list operation on this resource 🎀
availability_zone_hints — the availability zone hints used when scheduling the network. Type: list of availability zone names 🌸
availability_zones — the availability zones for the network. Type: list of availability zone names ⭐
created_at — timestamp of when the network was created ⏰
description — the network description 📝
dns_domain — the DNS domain that's associated 🦋
ipv4_address_scope_id — the ID of the IPv4 address scope for the network 🔢
ipv6_address_scope_id — the ID of the IPv6 address scope for the network 🔢
is_admin_state_up — the administrative state of the network: up is True, down is False. Type: bool 👑
is_default — whether this is the default external network or not. Type: bool 🌈
is_port_security_enabled — the port security status: enabled is True, disabled is False. Type: bool. Default: False. Available for multiple provider extensions 🔐
is_router_external — whether the router is external or not. Type: bool. Default: False 🚪
is_shared — says whether this network is shared across all projects. By default, only administrative users can change this value. Type: bool 🤝
mtu — read-only. The maximum transmission unit (MTU) of the network resource 📏
name — the network name 🏷️
project_id — the ID of the project this network is associated with 🗂️
provider_network_type — the type of physical network that maps to this network resource. Like, for example, flat, vlan, vxlan, or gre. Available for multiple provider extensions 🛰️
provider_physical_network — the physical network where this network object is actually implemented. Available for multiple provider extensions 🌐
provider_segmentation_id — an isolated segment ID on the physical network. The provider network type defines the segmentation model. Available for multiple provider extensions 🧩
pvlan — indicates if PVLAN is enabled for the network 🔒
qos_policy_id — the ID of the QoS policy attached to the port 🎚️
segments — a list of provider segment objects. Available for multiple provider extensions 📚
status — the network status 💫
subnet_ids — the associated subnet IDs. Type: list of strs of the subnet IDs 🧵
updated_at — timestamp of when the network was last updated 🔄
is_vlan_transparent — indicates the VLAN transparency mode of the network 🫧
is_vlan_qinq — indicates the VLAN QinQ mode of the network 🫧

🌈 `openstack.network.v2.network_ip_availability`

💖 The `NetworkIPAvailability` Class

The NetworkIPAvailability class inherits from Resource. No cap, it's literally just a Resource with a glow-up ✨

class openstack.network.v2.network_ip_availability.NetworkIPAvailability(_synchronized=False, connection=None, **attrs)

The base resource 🔮

Parameters

_synchronized — this is not intended to be used directly. See new() and existing(). iykyk 🙈
connection — reference to the Connection being used. Defaults to None so Resource objects can be used without an active Connection, like in unit tests. Any use of self._connection in Resource code should protect itself with a check for None. Very "protect your peace" of it 💅
resource_key = 'network_ip_availability' — the singular form of the key for the resource 🔑
resources_key = 'network_ip_availabilities' — the plural form of the key for the resource 🔑✨
base_path = '/network-ip-availabilities' — the base part of the URI for this resource 🛣️
allow_create = False — create operation? Not on this resource, bestie 🚫
allow_fetch = True — get operation? Yep, allowed 🫶
allow_commit = False — update operation? Nope 🚫
allow_delete = False — delete operation? Also nope 🚫
allow_list = True — list operation? Absolutely yes 🎀
network_id — network ID to use when listing network IP availability 🆔
network_name — the network name for that particular network IP availability 🏷️
subnet_ip_availability — the Subnet IP Availability of all subnets of a network. Type: list 📋
project_id — the ID of the project this network IP availability is associated with 🗂️
tenant_id — tenant_id (deprecated attribute 😭 yes, deprecated, keep that in mind)
total_ips — the total IPs of a network. Type: int 🔢
used_ips — the used or consumed IPs of a network. Type: int 🔢
ip_availability_details — the detailed IP availability of a network, holding the total_ips_in_subnet, total_ips_in_allocation_pool, used_ips_in_subnet and used_ips_in_allocation_pool keys. Requires the network-ip-availability-details extension. Type: dict 🧬

🦋 `openstack.network.v2.network_segment_range`

🌸 The `NetworkSegmentRange` Class

The NetworkSegmentRange class inherits from Resource.

class openstack.network.v2.network_segment_range.NetworkSegmentRange(_synchronized=False, connection=None, **attrs)

The base resource 🔮

Parameters

_synchronized — not intended to be used directly, fr. See new() and existing() 🙈
connection — reference to the Connection being used. Defaults to None so Resource objects work without an active Connection, like in unit tests. Any use of self._connection in Resource code should protect itself with a check for None 💅
resource_key = 'network_segment_range' — singular form of the key for the resource 🔑
resources_key = 'network_segment_ranges' — plural form of the key for the resource 🔑✨
base_path = '/network_segment_ranges' — the base part of the URI for this resource 🛣️
allow_create = True — create? yes 🫶
allow_fetch = True — get? yes ✨
allow_commit = True — update? yes 💅
allow_delete = True — delete? yes 🎀
allow_list = True — list? yes ⭐
name — the network segment range name 🏷️
default — the network segment range is loaded from the host configuration file. Type: bool 📄
shared — the network segment range is shared with other projects. Type: bool 🤝
project_id — the ID of the project associated with this network segment range 🗂️
network_type — the type of network associated with this network segment range, such as geneve, gre, vlan or vxlan 🛰️
physical_network — the name of the physical network associated with this network segment range 🌐
minimum — the minimum segmentation ID for this network segment range. The network type defines the segmentation model: VLAN ID for vlan network type, and tunnel ID for geneve, gre and vxlan network types. Type: int ⬇️
maximum — the maximum segmentation ID for this network segment range. The network type defines the segmentation model: VLAN ID for vlan network type, and tunnel ID for geneve, gre and vxlan network types. Type: int ⬆️
used — mapping of which segmentation ID in the range is used by which project. Type: dict 🗺️
available — list of available segmentation IDs in this network segment range. Type: list ✅

🎀 `openstack.network.v2.pool`

👑 The `Pool` Class

The Pool class inherits from Resource.

class openstack.network.v2.pool.Pool(_synchronized=False, connection=None, **attrs)

The base resource 🔮

Parameters

_synchronized — this is not intended to be used directly. See new() and existing() 🙈
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None 💅
resource_key = 'pool' — singular form of the key for the resource 🔑
resources_key = 'pools' — plural form of the key for the resource 🔑✨
base_path = '/lbaas/pools' — the base part of the URI for this resource 🛣️
allow_create = True — create operation? allowed 🫶
allow_fetch = True — get operation? allowed ✨
allow_commit = True — update operation? allowed 💅
allow_delete = True — delete operation? allowed 🎀
allow_list = True — list operation? allowed ⭐
description — description for the pool 📝
health_monitor_id — the ID of the associated health monitors 🩺
health_monitor_ids — the IDs of the health monitors that are, like, attached to this pool (that's the LBaaS v1 ones, bestie, vintage 💅).
health_monitor_status — the statuses of those associated health monitors. vibes check on the monitors ✨
is_admin_state_up — the admin state of the pool: up = True, down = False. Type: bool
load_balancer_id — ID of the load balancer that's associated with this pool.
member_ids — list of members that belong to the pool. Type: list of dicts which contain the member IDs
name — pool name. and no, it does NOT have to be unique, so go off I guess 🙈
project_id — the ID of the project this pool is associated with.
tenant_id — Tenant_id (deprecated attribute). it's giving legacy, don't use it.
protocol — the protocol of the pool, which is TCP, HTTP, or HTTPS.
provider — the provider name of the load balancer service.
status — human readable description of the status.
status_description — the status of the network.
subnet_id — the subnet on which the members of the pool will be located.
session_persistence — the session persistence algorithm that should be used (if any). Type: dict with keys type and cookie_name
virtual_ip_id — the ID of the virtual IP (VIP) address. very VIP of it 👑

`openstack.network.v2.pool_member`

The PoolMember Class

the PoolMember class inherits from Resource <#openstack.resource.Resource>. family tree slay 🌈

class openstack.network.v2.pool_member.PoolMember(_synchronized=False, connection=None, **attrs)

the base resource

Parameters

_synchronized — not intended to be used directly, bestie. see new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>. please don't touch this one 🙏
connection — reference to the Connection being used. defaults to None so Resource objects can be used without an active Connection, like in unit tests ngl. any use of self._connection in Resource code should protect itself with a check for None. periodt 💅

class attributes:

resource_key = 'member' — singular form of key for resource.
resources_key = 'members' — plural form of key for resource.
base_path = '/lbaas/pools/%(pool_id)s/members' — the base part of the URI for this resource.
allow_create = True — allow create operation for this resource.
allow_fetch = True — allow get operation for this resource.
allow_commit = True — allow update operation for this resource.
allow_delete = True — allow delete operation for this resource.
allow_list = True — allow list operation for this resource.

attributes, the main characters:

pool_id — the ID of the owning pool.
address — the IP address of the pool member.
is_admin_state_up — the admin state of the pool member: up = True, down = False. Type: bool
name — name of the pool member.
project_id — the ID of the project this pool member is associated with.
tenant_id — Tenant_id (deprecated attribute). yeah. that one. 💀
protocol_port — the port on which the application is hosted.
subnet_id — subnet ID in which to access this pool member.
weight — a positive integer value that indicates the relative portion of traffic that this member should receive from the pool. for example, a member with a weight of 10 receives five times as much traffic as a member with weight of 2. math is mathing, bestie 🍓

`openstack.network.v2.port`

The Port Class

the Port class inherits from Resource <#openstack.resource.Resource>. 🦋

class openstack.network.v2.port.Port(_synchronized=False, connection=None, **attrs)

the base resource

Parameters

_synchronized — not intended to be used directly! see new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
connection — reference to the Connection being used. defaults to None so Resource objects can be used without an active Connection, such as in unit tests. use of self._connection in Resource code should protect itself with a check for None. same deal as always 🫶

class attributes:

resource_key = 'port' — singular form of key for resource.
resources_key = 'ports' — plural form of key for resource.
base_path = '/ports' — the base part of the URI for this resource.
allow_create = True — allow create operation for this resource.
allow_fetch = True — allow get operation for this resource.
allow_commit = True — allow update operation for this resource.
allow_delete = True — allow delete operation for this resource.
allow_list = True — allow list operation for this resource.

attributes, and there are… a lot of them 😭:

allowed_address_pairs — allowed address pairs list. dictionary key ip_address is required and key mac_address is optional. don't forget the required one!!
binding_host_id — the ID of the host where the port is allocated. in some cases, different implementations can run on different hosts.
binding_profile — a dictionary that enables the application running on the specified host to pass and receive vif port-specific information to the plug-in. Type: dict
binding_vif_details — read-only. a dictionary that enables the application to pass information about functions that the Networking API provides. to enable or disable port filtering features such as security group and anti-MAC/IP spoofing, specify port_filter: True or port_filter: False. Type: dict
binding_vif_type — read-only. the vif type for the specified port.
binding_vnic_type — the vnic type that is bound to the neutron port.

in POST and PUT operations, specify a value of normal (virtual nic), direct (pci passthrough), or macvtap (virtual interface with a tap-like software interface). these values support SR-IOV PCI passthrough networking. the ML2 plug-in supports the vnic_type.

in GET operations, the binding:vnic_type extended attribute is visible to only port owners and administrative users. so if you can't see it, that's why, bestie 👀

created_at — timestamp when the port was created.
data_plane_status — underlying data plane status of this port.
description — the port description.
device_id — device ID of this port.
device_owner — device owner of this port (e.g. network:dhcp).
dns_assignment — DNS assignment for the port.
dns_domain — DNS domain assigned to the port.
dns_name — DNS name for the port.
extra_dhcp_opts — extra DHCP options.
fixed_ips — IP addresses for the port. includes the IP address and subnet ID.
is_admin_state_up — the admin state of the port: up = True, down = False. Type: bool
is_port_security_enabled — the port security status: enabled = True, disabled = False. Type: bool Default: False
mac_address — the MAC address of an allowed address pair.
name — the port name.
network_id — the ID of the attached network.
numa_affinity_policy — the NUMA affinity policy defined for this port.
project_id — the ID of the project who owns the network. only administrative users can specify a project ID other than their own. so don't try it if that's not you 🔥
tenant_id — Tenant_id (deprecated attribute). the sequel nobody asked for 💀
propagate_uplink_status — whether to propagate uplink status of the port. Type: bool
pvlan_type — the PVLAN type of the port. can be Promiscuous, Isolated or Community.
pvlan_community — the PVLAN community name. only needed if pvlan_type is Community. conditional queen 💅
qos_policy_id — the ID of the QoS policy attached to the port.
security_group_ids — the IDs of any attached security groups. Type: list of strs of the security group IDs
status — the port status. value is ACTIVE or DOWN.
trunk_details — read-only. the trunk referring to this parent port and its subports. present for trunk parent ports if the trunk-details extension is loaded. Type: dict with keys: trunk_id, sub_ports. sub_ports is a list of dicts with keys: port_id, segmentation_type, segmentation_id, mac_address nested dicts go brrr ✨
trusted — status of the trusted VIF setting. this value is added to the binding:profile field and passed to services which needs, it, like Nova.
updated_at — timestamp when the port was last updated.

`openstack.network.v2.qos_bandwidth_limit_rule`

The QoSBandwidthLimitRule Class

the QoSBandwidthLimitRule class inherits from Resource <#openstack.resource.Resource>. and that's where this part leaves you, bestie — more incoming 🎀

class openstack.network.v2.qos_bandwidth_limit_rule.QoSBandwidthLimitRule(_synchronized=False, connection=None, **attrs)

Bestie it's the base resource — that's genuinely the whole description, no cap. 💅

Parameters 🫶

_synchronized — okay so do not use this one directly, fr. Peep new() and existing() instead (the page keeps pointing at openstack.resource.Resource.new and openstack.resource.Resource.existing).
connection — the reference to the Connection being used. Defaults to None so you can have Resource objects with no live connection at all (unit tests love this, lowkey iconic). And if you're writing Resource code with self._connection, protect yourself with a check for None first. 👑
resource_key = 'bandwidth_limit_rule' — singular form of the key for the resource.
resources_key = 'bandwidth_limit_rules' — plural form of the key for the resource.
base_path = '/qos/policies/%(qos_policy_id)s/bandwidth_limit_rules' — the base part of the URI for this resource.
allow_create = True — create operation? allowed, slay.
allow_fetch = True — get operation? allowed 💖
allow_commit = True — update operation? allowed ✨
allow_delete = True — delete operation? allowed 🗑️
allow_list = True — list operation? allowed 🎀

Attributes, because yes there are more:

qos_policy_id — the ID of the QoS policy who owns the rule.
max_kbps — maximum bandwidth, in kbps.
max_burst_kbps — maximum burst bandwidth, in kbps.
direction — traffic direction from the project point of view: 'egress' or 'ingress'.

🦋 openstack.network.v2.qos_dscp_marking_rule

The QoSDSCPMarkingRule Class

The QoSDSCPMarkingRule class inherits from Resource (that's openstack.resource.Resource in the link, iykyk).

class openstack.network.v2.qos_dscp_marking_rule.QoSDSCPMarkingRule(_synchronized=False, connection=None, **attrs)

Again: the base resource. Iconic of it honestly.

Parameters 🌸

_synchronized — not for direct use, bestie, I'm begging. Go through new() (openstack.resource.Resource.new) and existing() (openstack.resource.Resource.existing) instead.
connection — reference to the Connection being used. Defaults to None so Resource objects can exist without an active connection (unit tests, we love you). Any self._connection use in Resource code should guard itself with a None check. 💜
resource_key = 'dscp_marking_rule' — singular form of the key for the resource.
resources_key = 'dscp_marking_rules' — plural form of the key for the resource.
base_path = '/qos/policies/%(qos_policy_id)s/dscp_marking_rules' — the base part of the URI for this resource.
allow_create = True — create: allowed ⭐
allow_fetch = True — get: allowed ⭐
allow_commit = True — update: allowed ⭐
allow_delete = True — delete: allowed ⭐
allow_list = True — list: allowed ⭐
qos_policy_id — the ID of the QoS policy who owns the rule.
dscp_mark — the DSCP mark field. That's it, that's the field. 💀

🌈 openstack.network.v2.qos_minimum_bandwidth_rule

The QoSMinimumBandwidthRule Class

The QoSMinimumBandwidthRule class inherits from Resource (openstack.resource.Resource).

class openstack.network.v2.qos_minimum_bandwidth_rule.QoSMinimumBandwidthRule(_synchronized=False, connection=None, **attrs)

Say it with me: the base resource.

Parameters 🎀

_synchronized — nope, don't touch it directly. See new() (openstack.resource.Resource.new) and existing() (openstack.resource.Resource.existing).
connection — reference to the Connection being used. Defaults to None so Resource objects work without an active connection (hello, unit tests). Any use of self._connection in Resource code should protect itself with a check for None.
resource_key = 'minimum_bandwidth_rule' — singular form of the key for the resource.
resources_key = 'minimum_bandwidth_rules' — plural form of the key for the resource.
base_path = '/qos/policies/%(qos_policy_id)s/minimum_bandwidth_rules' — the base part of the URI for this resource.
allow_create = True — create operation allowed.
allow_fetch = True — get operation allowed.
allow_commit = True — update operation allowed.
allow_delete = True — delete operation allowed.
allow_list = True — list operation allowed.
qos_policy_id — the ID of the QoS policy who owns the rule.
min_kbps — minimum bandwidth, in kbps.
direction — traffic direction from the project point of view. Valid values: 'egress'. Just the one, she's exclusive. 💅

🧚 openstack.network.v2.qos_minimum_packet_rate_rule

The QoSMinimumPacketRateRule Class

The QoSMinimumPacketRateRule class inherits from Resource (openstack.resource.Resource).

class openstack.network.v2.qos_minimum_packet_rate_rule.QoSMinimumPacketRateRule(_synchronized=False, connection=None, **attrs)

The base resource. Periodt.

Parameters 🍓

_synchronized — not intended for direct use, bestie. Check new() (openstack.resource.Resource.new) and existing() (openstack.resource.Resource.existing).
connection — reference to the Connection being used. Defaults to None, which is what lets Resource objects exist without an active connection — like in unit tests. If Resource code uses self._connection, it should protect itself with a check for None.
resource_key = 'minimum_packet_rate_rule' — singular form of the key for the resource.
resources_key = 'minimum_packet_rate_rules' — plural form of the key for the resource.
base_path = '/qos/policies/%(qos_policy_id)s/minimum_packet_rate_rules' — the base part of the URI for this resource.
allow_create = True — create operation allowed.
allow_fetch = True — get operation allowed.
allow_commit = True — update operation allowed.
allow_delete = True — delete operation allowed.
allow_list = True — list operation allowed.
direction — traffic direction from the project point of view. Valid values: ('any', 'egress', 'ingress') — she's got options, main character energy.
min_kpps — minimum packet rate, in kpps.
qos_policy_id — the ID of the QoS policy who owns the rule.

🔥 openstack.network.v2.qos_packet_rate_limit_rule

The QoSPacketRateLimitRule Class

The QoSPacketRateLimitRule class inherits from Resource (openstack.resource.Resource).

class openstack.network.v2.qos_packet_rate_limit_rule.QoSPacketRateLimitRule(_synchronized=False, connection=None, **attrs)

Base resource, we been knew. 💖

Parameters 🙈

_synchronized — yeah no, not directly. See new() (openstack.resource.Resource.new) and existing() (openstack.resource.Resource.existing).
connection — reference to the Connection being used. Defaults to None so Resource objects can be used without an active connection, e.g. in unit tests. Use of self._connection in Resource code should protect itself with a check for None.
resource_key = 'packet_rate_limit_rule' — singular form of the key for the resource.
resources_key = 'packet_rate_limit_rules' — plural form of the key for the resource.
base_path = '/qos/policies/%(qos_policy_id)s/packet_rate_limit_rules' — the base part of the URI for this resource.
allow_create = True — create operation allowed.
allow_fetch = True — get operation allowed.
allow_commit = True — update operation allowed.
allow_delete = True — delete operation allowed.
allow_list = True — list operation allowed.
qos_policy_id — the ID of the QoS policy who owns the rule.
max_kpps — maximum packet rate, in kpps.
max_burst_kpps — maximum burst packet rate, in kpps.

👑 openstack.network.v2.qos_policy

The QoSPolicy Class

The QoSPolicy class inherits from Resource (openstack.resource.Resource). Yes queen, the big one.

class openstack.network.v2.qos_policy.QoSPolicy(_synchronized=False, connection=None, **attrs)

And once more with feeling: the base resource.

Parameters 🫶

_synchronized — this is not intended to be used directly. See new() (openstack.resource.Resource.new) and existing() (openstack.resource.Resource.existing).
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.
resource_key = 'policy' — singular form of the key for the resource.
resources_key = 'policies' — plural form of the key for the resource.
base_path = '/qos/policies' — the base part of the URI for this resource.
allow_create = True — allow create operation for this resource.
allow_fetch = True — allow get operation for this resource.
allow_commit = True — allow update operation for this resource.
allow_delete = True — green light for the delete operation on this resource. 🗑️
allow_list = True — and yep, you can list it too. We stay permissive.
name — the QoS policy name. 📛
project_id — the ID of the project who owns the network. Heads up though: only administrative users can specify a project ID that isn't their own. 👀
tenant_id — Tenant_id (deprecated attribute). She's old, she's deprecated, she's still in the docs, so here she stays. 💀
description — the QoS policy description. 📝
is_default — indicates whether this QoS policy is the default policy for this project. Type: bool 👑
is_shared — indicates whether this QoS policy is shared across all projects. Type: bool 🌍
rules — list of QoS rules applied to this QoS policy. 📋

`set_tags(session, tags)`

Sets/replaces all tags on the resource. Not "adds" — replaces. Like, the whole tag list, gone, swapped. So maybe don't do that to your fave resource unless you mean it, bestie. 😭

Parameters:

session — the session to use for making this request.
tags (list) — list with tags to be set on the resource.

🦋 `openstack.network.v2.qos_rule_type`

The QoSRuleType Class

The QoSRuleType class inherits from Resource <#openstack.resource.Resource>.

class openstack.network.v2.qos_rule_type.QoSRuleType(_synchronized=False,
connection=None, **attrs)

The base resource. Parameters:

_synchronized — this is not intended to be used directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None. 🛡️
resource_key = 'rule_type' — singular form of the key for this resource.
resources_key = 'rule_types' — plural form of the key for this resource.
base_path = '/qos/rule-types' — the base part of the URI for this resource.
allow_create = False — nope, no creating these.
allow_fetch = True — fetching? absolutely, go off. ✨
allow_commit = False — no updating either.
allow_delete = False — and no deleting. Read-only energy, honestly iconic.
allow_list = True — but listing is fully allowed. 🌈
type — QoS rule type name.
drivers — list of QoS backend drivers supporting this QoS rule type. 🚗

🎀 `openstack.network.v2.quota`

The Quota Class

The Quota class inherits from Resource <#openstack.resource.Resource>.

class openstack.network.v2.quota.Quota(_synchronized=False,
connection=None, **attrs)

The base resource. Parameters:

_synchronized — this is not intended to be used directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None. 🔌
resource_key = 'quota' — singular form of the key for this resource.
resources_key = 'quotas' — plural form of the key for this resource.
base_path = '/quotas' — the base part of the URI for this resource.
allow_fetch = True — get operation? allowed. 💖
allow_commit = True — update operation? allowed.
allow_delete = True — delete operation? allowed, queen. 👑
allow_list = True — list operation? allowed.
check_limit — flag to check the quota usage before setting the new limit. Type: bool 🚦
floating_ips — the maximum amount of floating IPs you can have. Type: int
health_monitors — the maximum amount of health monitors you can create. Type: int
listeners — the maximum amount of listeners you can create. Type: int
load_balancers — the maximum amount of load balancers you can create. Type: int
l7_policies — the maximum amount of L7 policies you can create. Type: int
networks — the maximum amount of networks you can create. Type: int
pools — the maximum amount of pools you can create. Type: int
ports — the maximum amount of ports you can create. Type: int
project_id — the ID of the project these quota values are for.
tenant_id — Tenant_id (deprecated attribute). Still deprecated, still here. 💀
rbac_policies — the maximum amount of RBAC policies you can create. Type: int
router_routes — the maximum amount of router routes you can create. Type: int
routers — the maximum amount of routers you can create. Type: int
subnets — the maximum amount of subnets you can create. Type: int
subnet_pools — the maximum amount of subnet pools you can create. Type: int
security_group_rules — the maximum amount of security group rules you can create. Type: int
security_groups — the maximum amount of security groups you can create. Type: int

💜 `openstack.network.v2.rbac_policy`

The RBACPolicy Class

The RBACPolicy class inherits from Resource <#openstack.resource.Resource>.

class openstack.network.v2.rbac_policy.RBACPolicy(_synchronized=False,
connection=None, **attrs)

The base resource. Parameters:

_synchronized — this is not intended to be used directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None. 🫶
resource_key = 'rbac_policy' — singular form of the key for this resource.
resources_key = 'rbac_policies' — plural form of the key for this resource.
base_path = '/rbac-policies' — the base part of the URI for this resource.
allow_create = True — create operation? allowed. ✨
allow_fetch = True — get operation? allowed.
allow_commit = True — update operation? allowed.
allow_delete = True — delete operation? allowed.
allow_list = True — list operation? allowed. Full send, all five. 🔥
object_id — ID of the object that this RBAC policy affects.
target_project_id — the ID of the project this RBAC will be enforced.
project_id — the owner project ID.
tenant_id — Tenant_id (deprecated attribute). 🙈
object_type — type of the object that this RBAC policy affects.
action — action for the RBAC policy.

🌸 `openstack.network.v2.router`

The Router Class

The Router class inherits from Resource <#openstack.resource.Resource>.

class openstack.network.v2.router.Router(_synchronized=False,
connection=None, **attrs)

The base resource. Parameters:

_synchronized — this is not intended to be used directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None. 🧚
resource_key = 'router' — singular form of the key for this resource.
resources_key = 'routers' — plural form of the key for this resource.
base_path = '/routers' — the base part of the URI for this resource.
allow_create = True — create operation? allowed. 🎀
allow_fetch = True — get operation? allowed.
allow_commit = True — update operation? allowed.
allow_delete = True — delete operation? allowed.
allow_list = True — list operation? allowed. The full set, no notes. 💅
availability_zone_hints — availability zone hints to use when scheduling the router. Type: list of availability zone names 🗺️
availability_zones — availability zones for the router. Type: list of availability zone names
created_at — timestamp when the router was created.
description — the router description. 📝
enable_ndp_proxy — the ndp proxy state of the router.
evpn_vni — the EVPN VNI associated with the router, or None if EVPN is not configured. Type: int
external_gateway_info — the network_id, for the external gateway. Type: dict
flavor_id — the ID of the flavor.
is_admin_state_up — the administrative state of the router, which is up True or down False. Type: bool ⬆️⬇️
is_distributed — the distributed state of the router, which is distributed True or not False. Type: bool
is_ha — the highly-available state of the router: highly available True or not False. Type: bool 🌸
name — the router's name, bestie.
project_id — the ID of the project this router is associated with.
tenant_id — Tenant_id (deprecated attribute). 💀 yeah she's old, noted.
revision_number — revision number of the router. Type: int
routes — the extra routes configuration for the router.
status — the router status.
updated_at — timestamp when the router was created.
add_interface(session, **body) — add an internal interface to a logical router. 🫶

Parameters

session (Adapter) — the session to communicate through.
body (dict) — the body requested to be updated on the router.

Returns the body of the response as a dictionary.

Raises SDKException <#openstack.exceptions.SDKException> on error.

remove_interface(session, **body) — remove an internal interface from a logical router.

Parameters

session (Adapter) — the session to communicate through.
body (dict) — the body requested to be updated on the router.

Returns the body of the response as a dictionary.

Raises SDKException <#openstack.exceptions.SDKException> on error.

add_extra_routes(session, body) — add extra routes to a logical router. ✨

Parameters

session (Adapter) — the session to communicate through.
body (dict) — the request body as documented in the api-ref.

Returns the response as a Router object with the added extra routes.

Raises SDKException <#openstack.exceptions.SDKException> on error.

remove_extra_routes(session, body) — remove extra routes from a logical router.

Parameters

session (Adapter) — the session to communicate through.
body (dict) — the request body as documented in the api-ref.

Returns the response as a Router object with the extra routes left.

Raises SDKException <#openstack.exceptions.SDKException> on error.

add_gateway(session, **body) — add an external gateway to a logical router.

Parameters

session (Adapter) — the session to communicate through.
body (dict) — the body requested to be updated on the router.

Returns the body of the response as a dictionary.

remove_gateway(session, **body) — remove an external gateway from a logical router.

Parameters

session (Adapter) — the session to communicate through.
body (dict) — the body requested to be updated on the router.

Returns the body of the response as a dictionary.

add_external_gateways(session, body) — add external gateways to a router. 🦋

Parameters

session (Adapter) — the session to communicate through.
body (dict) — the body requested to be updated on the router.

Returns the body of the response as a dictionary.

update_external_gateways(session, body) — update external gateways of a router.

Parameters

session (Adapter) — the session to communicate through.
body (dict) — the body requested to be updated on the router.

Returns the body of the response as a dictionary.

remove_external_gateways(session, body) — remove external gateways from a router.

Parameters

session (Adapter) — the session to communicate through.
body (dict) — the body requested to be updated on the router.

Returns the body of the response as a dictionary.

🌈 `openstack.network.v2.security_group`

🎀 The SecurityGroup Class

okay so the SecurityGroup class inherits from Resource <#openstack.resource.Resource> — classic inheritance moment, we love to see it 💅

class openstack.network.v2.security_group.SecurityGroup(_synchronized=False, connection=None, **attrs)

The base resource. 👑

Parameters

_synchronized — this is not intended to be used directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None. 🫶
resource_key = 'security_group' — singular form of key for resource.
resources_key = 'security_groups' — plural form of key for resource.
base_path = '/security-groups' — the base part of the URI for this resource.
allow_create = True — allow create operation for this resource.
allow_fetch = True — allow get operation for this resource.
allow_commit = True — allow update operation for this resource.
allow_delete = True — allow delete operation for this resource.
allow_list = True — allow list operation for this resource.
created_at — timestamp when the security group was created.
description — the security group description.
name — the security group name.
stateful — whether the security group is stateful or not.
project_id — the ID of the project this security group is associated with.
security_group_rules — a list of SecurityGroupRule <#openstack.network.v2.security_group_rule.SecurityGroupRule> objects. Type: list 🌸
tenant_id — the ID of the project this security group is associated with.
updated_at — timestamp when the security group was last updated.
is_shared — indicates whether this Security Group is shared across all projects. Type: bool

🌈 `openstack.network.v2.security_group_rule`

🎀 The SecurityGroupRule Class

and the SecurityGroupRule class also inherits from Resource <#openstack.resource.Resource> — family business fr fr 💖

class openstack.network.v2.security_group_rule.SecurityGroupRule(_synchronized=False, connection=None, **attrs)

The base resource.

Parameters

_synchronized — this is not intended to be used directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.
resource_key = 'security_group_rule' — singular form of key for resource.
resources_key = 'security_group_rules' — plural form of key for resource.
base_path = '/security-group-rules' — the base part of the URI for this resource.
allow_create = True — allow create operation for this resource.
allow_fetch = True — allow get operation for this resource.
allow_commit = False — allow update operation for this resource. nope, no updating this one 🙈
allow_delete = True — allow delete operation for this resource.
allow_list = True — allow list operation for this resource.
created_at — timestamp when the security group rule was created.
description — the security group rule description.
direction — ingress or egress: the direction in which the security group rule is applied. For a compute instance, an ingress security group rule is applied to incoming ingress traffic for that instance. An egress rule is applied to traffic leaving the instance. 🚪✨
ether_type — must be IPv4 or IPv6, and addresses represented in CIDR must match the ingress or egress rules.
port_range_max — the maximum port number in the range that is matched by the security group rule. The port_range_min attribute constrains the port_range_max attribute. If the protocol is ICMP, this value must be an ICMP type.
port_range_min — the minimum port number in the range that is matched by the security group rule. If the protocol is TCP or UDP, this value must be less than or equal to the value of the port_range_max attribute. If the protocol is ICMP, this value must be an ICMP type.
project_id — the ID of the project this security group rule is associated with.
protocol — the protocol that is matched by the security group rule. Valid values are null, tcp, udp, and icmp. 🔥
remote_group_id — The remote security group ID to be associated with this security group rule. You can specify either remote_group_id or remote_address_group_id or remote_ip_prefix.
remote_address_group_id — The remote address group ID to be associated with this security group rule. You can specify either remote_group_id or remote_address_group_id or remote_ip_prefix.
remote_ip_prefix — The remote IP prefix to be associated with this security group rule. You can specify either remote_group_id or remote_address_group_id or remote_ip_prefix. This attribute matches the specified IP prefix as the source or destination IP address of the IP packet depending on direction.
security_group_id — The security group ID to associate with this security group rule.
tenant_id — The ID of the project this security group rule is associated with.
updated_at — Timestamp when the security group rule was last updated.

🌸 openstack.network.v2.segment

The Segment Class

The Segment class inherits from Resource.

class openstack.network.v2.segment.Segment(_synchronized=False,
connection=None, **attrs)

The base resource.

Parameters

_synchronized — This is not intended to be used directly. See new() and existing().
connection — Reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.
resource_key = 'segment' — Singular form of key for resource.
resources_key = 'segments' — Plural form of key for resource.
base_path = '/segments' — The base part of the URI for this resource.
allow_create = True — Allow create operation for this resource.
allow_fetch = True — Allow get operation for this resource.
allow_commit = True — Allow update operation for this resource.
allow_delete = True — Allow delete operation for this resource.
allow_list = True — Allow list operation for this resource.
description — The segment description.
name — The segment name.
network_id — The ID of the network associated with this segment.
network_type — The type of network associated with this segment, such as flat, geneve, gre, local, vlan or vxlan.
physical_network — The name of the physical network associated with this segment.
segmentation_id — The segmentation ID for this segment. The network type defines the segmentation model, VLAN ID for vlan network type and tunnel ID for geneve, gre and vxlan network types. Type: int.

🎀 openstack.network.v2.service_profile

The ServiceProfile Class

The ServiceProfile class inherits from Resource.

class openstack.network.v2.service_profile.ServiceProfile(_synchronized=False,
connection=None, **attrs)

The base resource.

Parameters

_synchronized — This is not intended to be used directly. See new() and existing().
connection — Reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.
resource_key = 'service_profile' — Singular form of key for resource.
resources_key = 'service_profiles' — Plural form of key for resource.
base_path = '/service_profiles' — The base part of the URI for this resource.
allow_create = True — Allow create operation for this resource.
allow_fetch = True — Allow get operation for this resource.
allow_commit = True — Allow update operation for this resource.
allow_delete = True — Allow delete operation for this resource.
allow_list = True — Allow list operation for this resource.
description — Description of the service flavor profile.
driver — Provider driver for the service flavor profile.
is_enabled — Sets enabled flag.
meta_info — Metainformation of the service flavor profile.
project_id — The owner project ID.
tenant_id — Tenant_id (deprecated attribute).

🦋 openstack.network.v2.service_provider

The Service Provider Class

The ServiceProvider class inherits from Resource.

class openstack.network.v2.service_provider.ServiceProvider(_synchronized=False,
connection=None, **attrs)

The base resource.

Parameters

_synchronized — This is not intended to be used directly. See new() and existing().
connection — Reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.
resources_key = 'service_providers' — Plural form of key for resource.
base_path = '/service-providers' — The base part of the URI for this resource.
allow_create = False — Allow create operation for this resource.
allow_fetch = False — Allow get operation for this resource.
allow_commit = False — Allow update operation for this resource.
allow_delete = False — Allow delete operation for this resource.
allow_list = True — Allow list operation for this resource.
service_type — Service type (FIREWALL, FLAVORS, METERING, QOS, etc..).
name — Name of the service type.
is_default — The default value of service type.

💜 openstack.network.v2.sfc_flow_classifier

The SfcFlowClassifier Class

The SfcFlowClassifier class inherits from Resource.

class openstack.network.v2.sfc_flow_classifier.SfcFlowClassifier(_synchronized=False,
connection=None, **attrs)

The base resource.

Parameters

_synchronized — This is not intended to be used directly. See new() and existing().
connection — Reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.
resource_key = 'flow_classifier' — Singular form of key for resource.
resources_key = 'flow_classifiers' — Plural form of key for resource.
base_path = '/sfc/flow_classifiers' — The base part of the URI for this resource.
allow_create = True — Allow create operation for this resource.
allow_fetch = True — Allow get operation for this resource.
allow_commit = True — Allow update operation for this resource.
allow_delete = True — Allow delete operation for this resource.
allow_list = True — Allow list operation for this resource.
description — Human-readable description for the resource.
name — Human-readable name of the resource. Default is an empty string.
protocol — The IP protocol can be represented by a string, an integer, or null. Valid values: any (0), ah (51), dccp (33), egp (8), esp (50), gre (47), icmp (1), icmpv6 (58), igmp (2), ipip (4), ipv6-encap (41), ipv6-frag (44), ipv6-icmp (58), ipv6-nonxt (59), ipv6-opts (60), ipv6-route (43), ospf (89), pgm (113), rsvp (46), sctp (132), tcp (6), udp (17), udplite (136), vrrp (112).
source_port_range_min — Minimum source protocol port.
source_port_range_max — Maximum source protocol port.
destination_port_range_min — Minimum destination protocol port.
destination_port_range_max — Maximum destination protocol port.
source_ip_prefix — The source IP prefix.
destination_ip_prefix — The destination IP prefix.
logical_source_port — The UUID of the source logical port.
logical_destination_port — The UUID of the destination logical port.
l7_parameters — A dictionary of L7 parameters, in the form of logical_source_network: uuid, logical_destination_network: uuid.
summary — Summary field of a Flow Classifier, composed of the protocol, source protocol port, destination protocol port, logical_source_port, logical_destination_port and l7_parameters.
tenant_id — Tenant_id (deprecated attribute).

🌈 openstack.network.v2.sfc_port_chain

The SfcPortChain Class

The SfcPortChain class inherits from Resource.

openstack.network.v2.sfc_port_chain — the SfcPortChain Class 💅

Lowkey obsessed with this one. It inherits from Resource (iykyk).

class openstack.network.v2.sfc_port_chain.SfcPortChain(_synchronized=False, connection=None, **attrs)

✨ The base resource

Parameters — yes bestie, same two as always:

_synchronized — do not use this directly, fr fr. Peep new() and existing() instead.
connection — a reference to the Connection being used. Defaults to None so Resource objects can exist without an active Connection (think unit tests 🧪). Any use of self._connection inside Resource code should protect itself with a None check.

The class attributes, no cap:

resource_key = 'port_chain' — the singular form of the key for this resource.
resources_key = 'port_chains' — the plural form, periodt.
base_path = '/sfc/port_chains' — the base part of the URI for this resource.
allow_create = True — create is allowed.
allow_fetch = True — get is allowed.
allow_commit = True — update is allowed.
allow_delete = True — delete is allowed.
allow_list = True — list is allowed. all five? she ate.

And the actual data fields:

description — human-readable description for the resource.
name — human-readable name of the resource. Default is an empty string.
port_pair_groups — list of port-pair-group UUIDs.
flow_classifiers — list of flow-classifier UUIDs.
chain_parameters — a dictionary of chain parameters; correlation values can be mpls and nsh, symmetric can be True or False.
tenant_id — Tenant_id (deprecated attribute ⚠️ she's old, we still list her).

openstack.network.v2.sfc_port_pair — the SfcPortPair Class 🦋

Inherits from Resource, obviously.

class openstack.network.v2.sfc_port_pair.SfcPortPair(_synchronized=False, connection=None, **attrs)

✨ The base resource

Parameters:

_synchronized — not for direct use, bestie. See new() and existing().
connection — reference to the Connection in play. Defaults to None so Resource objects can chill without an active Connection, like in unit tests. Guard any self._connection usage in Resource code with a None check.

Class attributes:

resource_key = 'port_pair' — singular key form.
resources_key = 'port_pairs' — plural key form.
base_path = '/sfc/port_pairs' — base part of the URI.
allow_create = True
allow_fetch = True
allow_commit = True
allow_delete = True
allow_list = True — every operation green-lit, we love a flexible queen 👑

Fields:

description — human-readable description for the resource.
name — human-readable name. Default is an empty string.
ingress — the UUID of the ingress Neutron port.
egress — the UUID of the egress Neutron port.
service_function_parameters — a dictionary of service function parameters. correlation values can be mpls and nsh; weight can be an int.
tenant_id — Tenant_id (deprecated attribute).

openstack.network.v2.sfc_port_pair_group — the SfcPortPairGroup Class 🎀

Inherits from Resource.

class openstack.network.v2.sfc_port_pair_group.SfcPortPairGroup(_synchronized=False, connection=None, **attrs)

✨ The base resource

Parameters:

_synchronized — seriously, don't touch it directly. See new() and existing().
connection — reference to the Connection being used. Defaults to None, so Resource objects work without an active Connection (unit tests, hii 👋). self._connection in Resource code should check for None first.

Class attributes:

resource_key = 'port_pair_group' — singular key form.
resources_key = 'port_pair_groups' — plural key form.
base_path = '/sfc/port_pair_groups' — base part of the URI.
allow_create = True
allow_fetch = True
allow_commit = True
allow_delete = True
allow_list = True

Fields:

description — human-readable description for the resource.
name — human-readable name. Default is an empty string.
port_pairs — list of port-pair UUIDs.
port_pair_group_parameters — dictionary of port pair group parameters, shaped like lb_fields: list of regex (eth|ip|tcp|udp)_(src|dst), and ppg_n_tuple_mapping: ingress_n_tuple or egress_n_tuple. The ingress or egress tuple is a dict with these keys: source_ip_prefix, destination_ip_prefix, source_port_range_min, source_port_range_max, destination_port_range_min, destination_port_range_max. (Yeah it's a lot — copy them exact, bestie.)
is_tap_enabled — True if passive Tap service functions support is enabled; default is False.
tenant_id — Tenant_id (deprecated attribute).

openstack.network.v2.sfc_service_graph — the SfcServiceGraph Class 🌈

Inherits from Resource. Main character energy, honestly.

class openstack.network.v2.sfc_service_graph.SfcServiceGraph(_synchronized=False, connection=None, **attrs)

✨ The base resource

Parameters:

_synchronized — not intended for direct use. See new() and existing().
connection — reference to the Connection being used. Defaults to None so Resource objects can be used without an active Connection, e.g. in unit tests. Use of self._connection in Resource code should protect itself with a None check.

Class attributes:

resource_key = 'service_graph' — singular key form.
resources_key = 'service_graphs' — plural key form.
base_path = '/sfc/service_graphs' — base part of the URI.
allow_create = True
allow_fetch = True
allow_commit = True
allow_delete = True
allow_list = True

Fields:

description — human-readable description for the resource.
name — human-readable name. Default is an empty string.
port_chains — a dictionary where the key is the source port chain and the value is a list of destination port chains.
tenant_id — Tenant_id (deprecated attribute).

openstack.network.v2.subnet — the Subnet Class 🫶

The icon herself. Inherits from Resource.

class openstack.network.v2.subnet.Subnet(_synchronized=False, connection=None, **attrs)

✨ The base resource

Parameters:

_synchronized — do not use directly, please and thank you. See new() and existing().
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.

Class attributes:

resource_key = 'subnet' — singular key form for the resource.
resources_key = 'subnets' — plural key form for the resource.
base_path = '/subnets' — the base part of the URI for this resource.
allow_create = True — allow create for this resource.
allow_fetch = True — allow get for this resource.
allow_commit = True — allow update for this resource.
allow_delete = True — allow delete for this resource.
allow_list = True — allow list for this resource.

Fields (get comfy, there's a bunch):

allocation_pools — list of allocation pools, each of which has a start and an end address for this subnet.
cidr — the CIDR.
created_at — timestamp when the subnet was created.
description — the subnet description.
dns_nameservers — a list of DNS nameservers.
dns_publish_fixed_ip — whether to publish DNS records for fixed IPs.
gateway_ip — the gateway IP address.
host_routes — a list of host routes.

okay so the subnet attributes finish out like this:

ip_version — the IP version, which is 4 or 6. Type: int
ipv6_address_mode — the IPv6 address modes which are 'dhcpv6-stateful', 'dhcpv6-stateless' or 'slaac'.
ipv6_ra_mode — the IPv6 router advertisements modes which can be 'slaac', 'dhcpv6-stateful', 'dhcpv6-stateless'.
is_dhcp_enabled — set to True if DHCP is enabled and False if DHCP is disabled. Type: bool
name — the subnet name.
network_id — the ID of the attached network.
prefix_length — the prefix length to use for subnet allocation from a subnet pool
project_id — the ID of the project this subnet is associated with.
tenant_id — Tenant_id (deprecated attribute). ⚠️
segment_id — the ID of the segment this subnet is associated with.
service_types — service types for this subnet
subnet_pool_id — the subnet pool ID from which to obtain a CIDR.
updated_at — timestamp when the subnet was last updated.
use_default_subnet_pool — whether to use the default subnet pool to obtain a CIDR.

🌸 openstack.network.v2.subnet_pool 🌸

💅 The SubnetPool Class

the SubnetPool class inherits from Resource. periodt.

class openstack.network.v2.subnet_pool.SubnetPool(_synchronized=False,
connection=None, **attrs)

The base resource

Parameters

_synchronized — this is not intended to be used directly. See new() and existing().
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.
resource_key = 'subnetpool' — singular form of key for resource. ✨
resources_key = 'subnetpools' — plural form of key for resource.
base_path = '/subnetpools' — the base part of the URI for this resource.
allow_create = True — allow create operation for this resource.
allow_fetch = True — allow get operation for this resource.
allow_commit = True — allow update operation for this resource.
allow_delete = True — allow delete operation for this resource.
allow_list = True — allow list operation for this resource.
address_scope_id — the ID of the address scope associated with the subnet pool.
created_at — timestamp when the subnet pool was created.
default_prefix_length — the length of the prefix to allocate when the cidr or prefixlen attributes are omitted when creating a subnet. Type: int
default_quota — a per-project quota on the prefix space that can be allocated from the subnet pool for project subnets. For IPv4 subnet pools, default_quota is measured in units of /32. For IPv6 subnet pools, default_quota is measured units of /64. All projects that use the subnet pool have the same prefix quota applied. Type: int
description — the subnet pool description.
ip_version — Read-only. the IP address family of the list of prefixes. Type: int
is_default — whether or not this is the default subnet pool. Type: bool
is_shared — indicates whether this subnet pool is shared across all projects. Type: bool
maximum_prefix_length — the maximum prefix length that can be allocated from the subnet pool. Type: int
minimum_prefix_length — the minimum prefix length that can be allocated from the subnet pool. Type: int
name — the subnet pool name.
project_id — the ID of the project that owns the subnet pool.
tenant_id — Tenant_id (deprecated attribute). ⚠️
prefixes — a list of subnet prefixes that are assigned to the subnet pool. The adjacent prefixes are merged and treated as a single prefix. Type: list
revision_number — revision number of the subnet pool. Type: int
updated_at — timestamp when the subnet pool was last updated.

🧚 `subnet_onboard(session, **body)`

onboard network subnets into a subnet pool. it's giving admin magic ✨

Parameters

session (Adapter) — the session to communicate through.
body — the request body (network_id).

Returns — the response body as a dictionary.

Raises — SDKException on error.

🦋 openstack.network.v2.tap_flow 🦋

💖 The TapFlow Class

the TapFlow class inherits from Resource.

class openstack.network.v2.tap_flow.TapFlow(_synchronized=False,
connection=None, **attrs)

Tap Flow

The base resource

Parameters

_synchronized — this is not intended to be used directly. See new() and existing().
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.
resource_key = 'tap_flow' — singular form of key for resource.
resources_key = 'tap_flows' — plural form of key for resource.
base_path = '/taas/tap_flows' — the base part of the URI for this resource.
allow_create = True — allow create operation for this resource.
allow_fetch = True — allow get operation for this resource.
allow_commit = True — allow update operation for this resource.
allow_delete = True — allow delete operation for this resource.
allow_list = True — allow list operation for this resource.
id — the ID of the tap flow.
name — the tap flow's name.
description — the tap flow's description.
project_id — the ID of the project that owns the tap flow.
tenant_id — Tenant_id (deprecated attribute). ⚠️
tap_service_id — the id of the tap_service with which the tap flow is associated
direction — the direction of the tap flow.
status — the status for the tap flow.
source_port — the id of the port the tap flow is associated with

🌈 openstack.network.v2.tap_mirror 🌈

🎀 The TapMirror Class

the TapMirror class inherits from Resource.

class openstack.network.v2.tap_mirror.TapMirror(_synchronized=False,
connection=None, **attrs)

Tap Mirror

The base resource

Parameters

_synchronized — this is not intended to be used directly. See new() and existing().
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.
resource_key = 'tap_mirror' — singular form of key for resource.
resources_key = 'tap_mirrors' — plural form of key for resource.
base_path = '/taas/tap_mirrors' — the base part of the URI for this resource.
allow_create = True — allow create operation for this resource.
allow_fetch = True — allow get operation for this resource.
allow_commit = True — allow update operation for this resource.
allow_delete = True — allow delete operation for this resource.
allow_list = True — allow list operation for this resource.
id — the ID of the Tap Mirror.
name — the Tap Mirror name.
description — the Tap Mirror description.
project_id — the ID of the project that owns the Tap Mirror.
tenant_id — Tenant_id (deprecated attribute). ⚠️
port_id — the id of the port the Tap Mirror is associated with
directions — the status for the tap service.
remote_ip — the destination IP address of the Tap Mirror
mirror_type — the type of the Tap Mirror, it can be gre or erspanv1

🌟 openstack.network.v2.tap_service 🌟

🫶 The TapService Class

the TapService class inherits from Resource.

class openstack.network.v2.tap_service.TapService(_synchronized=False,
connection=None, **attrs)

Tap Service

The base resource

Parameters

_synchronized — this is not intended to be used directly. See new() and existing().
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.
resource_key = 'tap_service' — the singular form of the key for this resource, iykyk ✨
resources_key = 'tap_services' — and the plural form of the key for the resource 🎀
base_path = '/taas/tap_services' — the base part of the URI for this resource, literally just that 💅
allow_create = True — yep, create operations are allowed on this one 🫶
allow_fetch = True — and get operations too, no cap
allow_commit = True — update operations? allowed. slay ✨
allow_delete = True — delete operations also on the menu 💀
allow_list = True — and listing, obviously, it's giving full permissions 🌈
id — the ID of the tap service 🔥
name — the tap service name 🌸
description — the tap service description 🎀
project_id — the ID of the project that owns the tap service 👑
tenant_id — Tenant_id, and bestie it's a deprecated attribute, so like… noted 💀
port_id — the id of the port the tap service is associated with 🦋
status — the status for the tap service ⭐

🦋 VPNaaS Resources 🦋

🌸 `openstack.network.v2.vpn_endpoint_group` 🌸

The VpnEndpointGroup Class ✨

The VpnEndpointGroup class inherits from Resource <#openstack.resource.Resource>. Inheritance, we love to see it 💖

class openstack.network.v2.vpn_endpoint_group.VpnEndpointGroup(_synchronized=False, connection=None, **attrs)

The base resource 👑

Parameters

_synchronized — this is not intended to be used directly, fr fr. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing> 🙈
connection — reference to the Connection being used. It defaults to None so that Resource objects can be used without an active Connection, like in unit tests 🧚. Any use of self._connection in Resource code should protect itself with a check for None 💅
resource_key = 'endpoint_group' — singular form of key for resource ✨
resources_key = 'endpoint_groups' — plural form of key for resource 🎀
base_path = '/vpn/endpoint-groups' — the base part of the URI for this resource 🌈
allow_create = True — allow create operation for this resource 🫶
allow_fetch = True — allow get operation for this resource 🌸
allow_commit = True — allow update operation for this resource ✨
allow_delete = True — allow delete operation for this resource 💀
allow_list = True — allow list operation for this resource ⭐
description — human-readable description for the resource 💖
endpoints — list of endpoints of the same type, for the endpoint group. The values will depend on type 🦋
name — human-readable name of the resource. Default is an empty string 🎀
tenant_id — Tenant_id, and yes it's a deprecated attribute 💀
type — the type of the endpoints in the group. A valid value is subnet, cidr, network, router, or vlan. Only subnet and cidr are supported at this moment, so don't get cute with the others 🙈

💜 `openstack.network.v2.vpn_ike_policy` 💜

The VpnIkePolicy Class ✨

The VpnIkePolicy class inherits from Resource <#openstack.resource.Resource>. iconic behavior 👑

class openstack.network.v2.vpn_ike_policy.VpnIkePolicy(_synchronized=False, connection=None, **attrs)

VPN IKE policy extension. 🔥

The base resource 👑

Parameters

_synchronized — this is not intended to be used directly, bestie. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing> 🙈
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests 🧚. Use of self._connection in Resource code should protect itself with a check for None 💅
resource_key = 'ikepolicy' — singular form of key for resource ✨
resources_key = 'ikepolicies' — plural form of key for resource 🎀
base_path = '/vpn/ikepolicies' — the base part of the URI for this resource 🌈
allow_create = True — allow create operation for this resource 🫶
allow_fetch = True — allow get operation for this resource 🌸
allow_commit = True — allow update operation for this resource ✨
allow_delete = True — allow delete operation for this resource 💀
allow_list = True — allow list operation for this resource ⭐
ike_version — the IKE version. A valid value is v1 or v2. Default is v1 🦋
name — human-readable name of the resource. Default is an empty string 🎀
project_id — the ID of the project 👑
phase1_negotiation_mode — the IKE mode. A valid value is main, which is the default 💅

🎀 `openstack.network.v2.vpn_ipsec_policy` 🎀

The VpnIpsecPolicy Class ✨

The VpnIpsecPolicy class inherits from Resource <#openstack.resource.Resource>. we stan a class hierarchy 💖

class openstack.network.v2.vpn_ipsec_policy.VpnIpsecPolicy(_synchronized=False, connection=None, **attrs)

The base resource 👑

Parameters

_synchronized — not intended to be used directly, fr fr. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing> 🙈
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests 🧚. Use of self._connection in Resource code should protect itself with a check for None 💅
resource_key = 'ipsecpolicy' — singular form of key for resource ✨
resources_key = 'ipsecpolicies' — plural form of key for resource 🎀
base_path = '/vpn/ipsecpolicies' — the base part of the URI for this resource 🌈
allow_create = True — allow create operation for this resource 🫶
allow_fetch = True — allow get operation for this resource 🌸
allow_commit = True — allow update operation for this resource ✨
allow_delete = True — allow delete operation for this resource 💀
allow_list = True — allow list operation for this resource ⭐
encapsulation_mode — the encapsulation mode. A valid value is tunnel or transport 🦋
name — human-readable name of the resource. Default is an empty string 🎀
project_id — the ID of the project 👑
phase1_negotiation_mode — the IKE mode. A valid value is main, which is the default 💅
transform_protocol — the transform protocol. A valid value is ESP, AH, or AH-ESP 🔥

🌈 `openstack.network.v2.vpn_ipsec_site_connection` 🌈

The VpnIPSecSiteConnection Class ✨

The VpnIPSecSiteConnection class inherits from Resource <#openstack.resource.Resource>. long name but she's valid 💅

class openstack.network.v2.vpn_ipsec_site_connection.VpnIPSecSiteConnection(_synchronized=False, connection=None, **attrs)

The base resource 👑

Parameters

_synchronized — not intended to be used directly, bestie. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing> 🙈
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests 🧚. Use of self._connection in Resource code should protect itself with a check for None 💅
resource_key = 'ipsec_site_connection' — singular form of key for resource ✨
resources_key = 'ipsec_site_connections' — plural form of key for resource 🎀
base_path = '/vpn/ipsec-site-connections' — the base part of the URI for this resource 🌈
allow_create = True — allow create operation for this resource 🫶
allow_fetch = True — allow get operation for this resource 🌸
allow_commit = True — allow update operation for this resource ✨
allow_delete = True — allow delete operation for this resource 💀
allow_list = True — allow list operation for this resource ⭐
dpd — a dictionary with dead peer detection (DPD) protocol controls 💀 (the acronym really said 💀)
ikepolicy_id — the ID of the IKE policy 🦋
ipsecpolicy_id — the ID of the IPsec policy 🦋
peer_address — the peer gateway public IPv4 or IPv6 address or FQDN 🌸
name — human-readable name of the resource. Default is an empty string 🎀
project_id — the ID of the project 👑
psk — the pre-shared key. A valid value is any string 🔥
route_mode — the route mode. A valid value is static, which is the default 💅
status — the site connection status ⭐
vpnservice_id — the ID of the VPN service 🫶

👑 `openstack.network.v2.vpn_service` 👑

The VpnService Class ✨

The VpnService class inherits from Resource <#openstack.resource.Resource>. main character energy, honestly 💖

class openstack.network.v2.vpn_service.VpnService(_synchronized=False, connection=None, **attrs)

The base resource 👑

Parameters

_synchronized — not intended to be used directly, fr. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing> 🙈
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests 🧚. Use of self._connection in Resource code should protect itself with a check for None 💅
resource_key = 'vpnservice' — singular form of key for resource ✨
resources_key = 'vpnservices' — the plural form of the key for this resource, bestie ✨
base_path = '/vpn/vpnservices' — the base part of the URI for this resource, slay 🎀
allow_create = True — create operation? allowed, periodt 💅
allow_fetch = True — get operation? also allowed, we love to see it 💖
allow_commit = True — update operation? green light, no cap 🟢
allow_delete = True — delete operation? yes babes, go off 🔥
allow_list = True — list operation? obviously, she contains multitudes ⭐
description — a human-readable description for the vpnservice, literally just words for humans 🫶
external_v4_ip — the external IPv4 address that's used for the VPN service 🌈
external_v6_ip — the external IPv6 address that's used for the VPN service, her sibling 🦋
is_admin_state_up — the administrative state of the vpnservice, which is up True or down False. Type: bool 👑
name — the vpnservice name, iconic as always 💜
router_id — ID of the router into which the VPN service is inserted 🔌
project_id — the ID of the project this vpnservice is associated with 🏷️
tenant_id — Tenant_id (deprecated attribute). It's giving vintage, but deprecated is deprecated, so note it and move on 🙈
status — the vpnservice status, her current mood basically 💀
subnet_id — the ID of the subnet on which the tenant wants the vpnservice 🌸

🧚 Orchestration Resources 🧚

🎀 `openstack.orchestration.v1.resource`

The Resource Class

The Resource class inherits from Resource <#openstack.resource.Resource>. Family tree: noted 💅

class openstack.orchestration.v1.resource.Resource(_synchronized=False, connection=None, **attrs)

The base resource, aka the blueprint every other bb takes after 👑

Parameters

_synchronized — this is not intended to be used directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing> instead, bestie, don't touch it 🙈
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None ⚠️
resource_key = 'resource' — singular form of key for resource ✨
resources_key = 'resources' — plural form of key for resource, matching set 🌈
base_path = '/stacks/%(stack_name)s/%(stack_id)s/resources' — the base part of the URI for this resource 🛣️
allow_create = False — create operation? not for this one, she said no 🚫
allow_list = True — list operation? yes ma'am 💖
allow_delete = False — delete operation? nope 🙅
allow_commit = False — update operation? also nope, we respect the boundaries 💅
links — a list of dictionaries containing links relevant to the resource 🔗
logical_resource_id — ID of the logical resource, usually the literal name of the resource as it appears in the stack template 📝
name — name of the resource, short and sweet 🎀
physical_resource_id — ID of the physical resource (if any) that backs up the resource. For example, it contains a nova server ID if the resource is a nova server 🖥️
required_by — a list of resource names that depend on this resource. This property facilitates the deduction of resource dependencies. Type: list 🧠
resource_type — a string representation of the resource type 🔤
status — a string representing the status the resource is currently in 📊
status_reason — a string that explains why the resource is in its current status. The "why tho" field, honestly 😭
updated_at — timestamp of the last update made to the resource 🕰️

🦋 `openstack.orchestration.v1.software_config`

The SoftwareConfig Class

The SoftwareConfig class inherits from Resource <#openstack.resource.Resource>. Another nepo baby, but make it config 💜

class openstack.orchestration.v1.software_config.SoftwareConfig(_synchronized=False, connection=None, **attrs)

The base resource 👑

Parameters

_synchronized — this is not intended to be used directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing> 🙈
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None ⚠️
resource_key = 'software_config' — singular form of key for resource ✨
resources_key = 'software_configs' — plural form of key for resource 🌈
base_path = '/software_configs' — the base part of the URI for this resource 🛣️
allow_create = True — create operation? absolutely, go off 🔥
allow_list = True — list operation? yes babes 💖
allow_fetch = True — get operation? mhm 🫶
allow_delete = True — delete operation? she can, and she will 💅
allow_commit = False — update operation? not here, no thank you 🚫
create_opts = CreateOpts(request_key=None, response_key=<Unset.UNSET: 'UNSET'>, method='POST', requires_id=<Unset.UNSET: 'UNSET'>, response_has_body=True) — class-level configuration for the create operation. Subclasses can override this to set per-resource defaults without overriding create() ⚙️
config — configuration script or manifest that defines which configuration is performed 📜
created_at — the date and time when the software config resource was created 🕰️
group — a string indicating the namespace used for grouping software configs 🗂️
inputs — a list of schemas each representing an input this software config expects 📥
name — name of the software config 🎀
options — a string that contains options that are specific to the configuration management tool that this resource uses 🔧
outputs — a list of schemas each representing an output this software config produces 📤

⭐ `openstack.orchestration.v1.software_deployment`

The SoftwareDeployment Class

The SoftwareDeployment class inherits from Resource <#openstack.resource.Resource>. Okay deploy queen 👑

class openstack.orchestration.v1.software_deployment.SoftwareDeployment(_synchronized=False, connection=None, **attrs)

The base resource ✨

Parameters

_synchronized — this is not intended to be used directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing> 🙈
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None ⚠️
resource_key = 'software_deployment' — singular form of key for resource ✨
resources_key = 'software_deployments' — plural form of key for resource 🌈
base_path = '/software_deployments' — the base part of the URI for this resource 🛣️
allow_create = True — create operation? yup 💖
allow_list = True — list operation? yup 🫶
allow_fetch = True — get operation? yup 🌸
allow_delete = True — delete operation? yup, she's thorough 💅
allow_commit = True — update operation? also yup, full send 🔥
create_opts = CreateOpts(request_key=None, response_key=<Unset.UNSET: 'UNSET'>, method='POST', requires_id=<Unset.UNSET: 'UNSET'>, response_has_body=True) — class-level configuration for the create operation. Subclasses can override this to set per-resource defaults without overriding create() ⚙️
action — the stack action that triggers this deployment resource 🎬
config_id — the UUID of the software config resource that runs when applying to the server 🆔
input_values — a map containing the names and values of all inputs to the config 🗺️
output_values — a map containing the names and values from the deployment 📤
server_id — the UUID of the compute server to which the configuration applies 🖥️
stack_user_project_id — the ID of the authentication project which can also perform operations on this deployment 🔑
status — current status of the software deployment 📊
status_reason — error description for the last status change. Like, what went wrong and why 😭
created_at — the date and time when the software deployment resource was created 🕰️
updated_at — the date and time when the software deployment resource was created (yes, that's literally what the original says, we're not editing it, fr fr) 🙈

commit(session, prepend_key=False, *args, **kwargs)

Commit the state of the instance to the remote resource. Sending her off into the world 🕊️

Parameters

session — the session to use for making this request 🌐
prepend_key — whether the resource_key <#openstack.resource.Resource.resource_key> should be prepended in a resource creation request. Default to True 🗝️
retry_on_conflict — whether to enable retries on HTTP CONFLICT (409). Value of None leaves the Adapter defaults 🔁
base_path — base part of the URI for modifying resources, if it's different from base_path <#openstack.resource.Resource.base_path>.
microversion — the API version to override the negotiated one.
attrs — attributes to pass when updating the resource. These should correspond to either Body or Header values on the resource.

Returns — this Resource instance. 🫶

Raises MethodNotSupported <#openstack.exceptions.MethodNotSupported> if Resource.allow_commit is not set to True.

🌈 openstack.orchestration.v1.stack

💜 The Stack Class

okay so the Stack class lowkey inherits from Resource <#openstack.resource.Resource>, which is giving "child of a legend" energy fr fr.

class openstack.orchestration.v1.stack.Stack(_synchronized=False, connection=None, **attrs)

The base resource 👑

Parameters:

_synchronized — this is not intended to be used directly, bestie. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
connection — reference to the Connection being used. It defaults to None so that Resource objects can be used without an active Connection, like in unit tests. Use of self._connection in Resource code should protect itself with a check for None.
resource_key = 'stack' — singular form of key for resource.
resources_key = 'stacks' — plural form of key for resource.
base_path = '/stacks' — the base part of the URI for this resource.
allow_create = True — allow create operation for this resource.
allow_list = True — allow list operation for this resource.
allow_fetch = True — allow get operation for this resource.
allow_commit = True — allow update operation for this resource.
allow_delete = True — allow delete operation for this resource.
create_opts = CreateOpts(request_key=None, response_key=<Unset.UNSET: 'UNSET'>, method='POST', requires_id=<Unset.UNSET: 'UNSET'>, response_has_body=True) — class-level configuration for the create operation. Subclasses can override this to set per-resource defaults without overriding create(). very much "configure, don't rewrite" energy ✨
capabilities — placeholder for AWS compatible template listing capabilities required by the stack.
created_at — timestamp of the stack creation.
description — a text description of the stack.
deleted — a list of resource objects that will be deleted if a stack update is performed.
deleted_at — timestamp of the stack deletion.
environment — a JSON environment for the stack.
environment_files — an ordered list of names for environment files found in the files dict.
files — additional files referenced in the template or the environment.
files_container — name of the container in swift that has child templates and environment files.
is_rollback_disabled — whether the stack will support a rollback operation on stack create/update failures. Type: bool
links — a list of dictionaries containing links relevant to the stack.
name — name of the stack.
notification_topics — placeholder for future extensions where stack related events can be published.
outputs — a list containing output keys and values from the stack, if any.
owner_id — the ID of the owner stack if any.
parameters — a dictionary containing the parameter names and values for the stack.
parent_id — the ID of the parent stack if any.
replaced — a list of resource objects that will be replaced if a stack update is performed.
status — a string representation of the stack status, e.g. CREATE_COMPLETE.
status_reason — a text explaining how the stack transits to its current status.
tags — a list of strings used as tags on the stack.
template — a dict containing the template use for stack creation.
template_description — stack template description text. Currently contains the same text as that of the description property.
template_url — a string containing the URL where a stack template can be found.
timeout_mins — stack operation timeout in minutes.
unchanged — a list of resource objects that will remain unchanged if a stack update is performed.
updated — a list of resource objects that will have their properties updated in place if a stack update is performed.
updated_at — timestamp of last update on the stack.
user_project_id — the ID of the user project created for this stack.

commit(session, prepend_key=True, has_body=True, retry_on_conflict=None, base_path=None, *, microversion=None, preview=False, **kwargs)

Commit the state of the instance to the remote resource. like, actually push it up there 💅

Parameters:

session — the session to use for making this request.
prepend_key — whether the resource_key <#openstack.resource.Resource.resource_key> should be prepended in a resource creation request. Defaults to True.
retry_on_conflict — whether to enable retries on HTTP CONFLICT (409). A value of None leaves the Adapter defaults.
base_path — base part of the URI for modifying resources, if it's different from base_path <#openstack.resource.Resource.base_path>.
microversion — the API version to override the negotiated one.
attrs — attributes to pass when updating the resource. These should correspond to either Body or Header values on the resource.

Returns — this Resource instance.

Raises MethodNotSupported <#openstack.exceptions.MethodNotSupported> if Resource.allow_commit is not set to True.

export(session)

Export a stack data 🎀

Parameters:

session — the session to use for making this request.

Returns — a dictionary containing the stack data.

suspend(session)

Suspend a stack 😴

Parameters:

session — the session to use for making this request

Returns — None

resume(session)

Resume a stack ⭐ (wake up bestie, we're going back in)

Parameters:

session — the session to use for making this request

Returns — None

fetch(session, requires_id=True, base_path=None, error_message=None, skip_cache=False, *, resolve_outputs=True, **params)

Get a remote resource based on this instance. 🔥

Parameters:

session — the session to use for making this request.
requires_id — whether resource ID should be part of the requested URI.
base_path — base part of the URI for fetching resources, if it's different from base_path <#openstack.resource.Resource.base_path>.
error_message — an error message to be returned if requested object does not exist.
skip_cache — a boolean indicating whether optional API cache should be skipped for this invocation.
resource_response_key — overrides the usage of self.resource_key when processing the response body.
microversion — the API version to override the negotiated one.
params — additional parameters that can be consumed.

Returns — this Resource instance.

Raises MethodNotSupported <#openstack.exceptions.MethodNotSupported> if Resource.allow_fetch is not set to True.

Raises NotFoundException <#openstack.exceptions.NotFoundException> if the resource was not found.

classmethod find(session, name_or_id, ignore_missing=True, list_base_path=None, *, microversion=None, all_projects=None, **params)

Find a resource by its name or id. 🕵️‍♀️ the scavenger hunt but make it API

Parameters:

session (Adapter) — the session to use for making this request.
name_or_id — this resource's identifier, if needed by the request. The default is None.
ignore_missing (bool) — when set to False, NotFoundException <#openstack.exceptions.NotFoundException> will be raised when the resource does not exist. When set to True, None will be returned when attempting to find a nonexistent resource.
params (dict) — literally any extra params you want passed down into the underlying methods, like into existing() when you're trying to hand off URI parameters. 🫶

Returns — the Resource object that matches the name or id you gave it, or None if nothing matches. Ngl, None is a real possibility here. 😭

Raises openstack.exceptions.DuplicateResource — if more than one resource comes back for this request. Like, bestie, pick one. 💀

Raises openstack.exceptions.NotFoundException — if nothing is found and ignore_missing is False.

💜 openstack.orchestration.v1.stack_environment

🎀 The `StackEnvironment` Class

The StackEnvironment class inherits from Resource. Iconic inheritance moment, we love to see it. 👑

class openstack.orchestration.v1.stack_environment.StackEnvironment(_synchronized=False, connection=None, **attrs)

The base resource ✨

Parameters

_synchronized — okay so this one is not meant to be used directly, fr fr. See new() and existing() instead.
connection — a reference to the Connection being used. Defaults to None so Resource objects can vibe without an active Connection, like in unit tests. And any use of self._connection in Resource code should protect itself with a check for None. Lowkey important. 🫶

base_path = '/stacks/%(stack_name)s/%(stack_id)s/environment' — the base part of the URI for this resource.

allow_create = False — allow create operation for this resource.

allow_list = False — allow list operation for this resource.

allow_fetch = True — allow get operation for this resource. ✅

allow_delete = False — allow delete operation for this resource.

allow_commit = False — allow update operation for this resource.

name — name of the stack where the template is referenced.

id — ID of the stack where the template is referenced.

encrypted_param_names — a list of parameter names whose values are encrypted. 🤫

event_sinks — a list of event sinks.

parameter_defaults — a map of parameters and their default values defined for the stack.

parameters — a map of parametes defined in the stack template. (Yes, "parametes" — that's the original spelling, I'm not touching it, I'm just the messenger 💅)

resource_registry — a map containing customized resource definitions.

🦋 openstack.orchestration.v1.stack_event

🌸 The `StackEvent` Class

The StackEvent class inherits from Resource.

class openstack.orchestration.v1.stack_event.StackEvent(_synchronized=False, connection=None, **attrs)

The base resource ✨

Parameters

_synchronized — not intended to be used directly, bestie. See new() and existing().
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.

base_path = '/stacks/%(stack_name)s/%(stack_id)s/events' — the base part of the URI for this resource.

resources_key = 'events' — plural form of key for resource.

allow_create = False — allow create operation for this resource.

allow_list = True — allow list operation for this resource. 🗒️

allow_fetch = True — allow get operation for this resource.

allow_delete = False — allow delete operation for this resource.

allow_commit = False — allow update operation for this resource.

event_time — the date and time when the event was created. ⏰

id — the ID of the event object.

links — a list of dictionaries containing links relevant to the stack. 🔗

logical_resource_id — the ID of the logical stack resource.

physical_resource_id — the ID of the stack physical resource.

resource_name — the name of the resource.

resource_status — the status of the resource.

resource_status_reason — the reason for the current stack resource state.

🧚 openstack.orchestration.v1.stack_files

🍓 The `StackFiles` Class

The StackFiles class inherits from Resource.

class openstack.orchestration.v1.stack_files.StackFiles(_synchronized=False, connection=None, **attrs)

The base resource ✨

Parameters

_synchronized — not for direct use, babes. See new() and existing().
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.

base_path = '/stacks/%(stack_name)s/%(stack_id)s/files' — the base part of the URI for this resource.

allow_create = False — allow create operation for this resource.

allow_list = False — allow list operation for this resource.

allow_fetch = True — allow get operation for this resource.

allow_delete = False — allow delete operation for this resource.

allow_commit = False — allow update operation for this resource.

name — name of the stack where the template is referenced.

id — ID of the stack where the template is referenced.

💅 `fetch(session, requires_id=False, base_path=None, *args, **kwargs)`

Get a remote resource based on this instance. Go get it, girl. 🔥

Parameters

session — the session to use for making this request.
requires_id — whether resource ID should be part of the requested URI.
base_path — base part of the URI for fetching resources, if different from base_path.
error_message — an error message to be returned if the requested object does not exist.
skip_cache — a boolean indicating whether the optional API cache should be skipped for this invocation.
resource_response_key — overrides the usage of self.resource_key when processing the response body.
microversion — API version to override the negotiated one.
params — additional parameters that can be consumed.

Returns — this Resource instance. 🫶

Raises MethodNotSupported — if Resource.allow_fetch is not set to True.

Raises NotFoundException — if the resource was not found. 😭

⭐ openstack.orchestration.v1.stack_template

🌈 The `StackTemplate` Class

The StackTemplate class inherits from Resource.

class openstack.orchestration.v1.stack_template.StackTemplate(_synchronized=False, connection=None, **attrs)

The base resource ✨

Parameters

_synchronized — genuinely not meant to be used directly. See new() and existing().
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.

base_path = '/stacks/%(stack_name)s/%(stack_id)s/template' — the base part of the URI for this resource.

allow_create = False — allow create operation for this resource.

allow_list = False — allow list operation for this resource.

allow_fetch = True — allow get operation for this resource.

allow_delete = False — allow delete operation for this resource.

allow_commit = False — allow update operation for this resource.

name — name of the stack where the template is referenced.

stack_id — ID of the stack where the template is referenced.

description — the description specified in the template.

heat_template_version — the version of the orchestration HOT template.

outputs — key and value that contain output data.

parameters — key and value pairs that contain template parameters.

resources — key and value pairs that contain definition of resources in the template.

🎀 openstack.orchestration.v1.template

👑 The `Template` Class

The Template class inherits from Resource.

class openstack.orchestration.v1.template.Template(_synchronized=False, connection=None, **attrs)

The base resource ✨

Parameters

_synchronized — this is not intended to be used directly, okay? See new() and existing().
connection — the hookup to the Connection being used. Defaults to None so you can totally use Resource objects with no live Connection hanging around (unit tests, we're looking at you 👀). If you're poking at self._connection inside Resource code, guard it with a None check, bestie — non-negotiable 🫶
allow_create = False — nope, no creating with this resource.
allow_list = False — no listing either.
allow_fetch = False — fetch? blocked, sorry babe.
allow_delete = False — deleting is a no.
allow_commit = False — and no updating. Very "look don't touch" of it 💅
description — the description that was specified in the template.
parameters — key and value pairs holding the template parameters.
parameter_groups — a list of parameter groups, and each one contains a list of parameter names.

🗄️ Object Store Resources 🗄️

💾 `openstack.object_store.v1.account`

✨ The Account Class ✨ — it inherits from Resource (peep <#openstack.resource.Resource>).

class openstack.object_store.v1.account.Account(metadata=None, **attrs)

Processes and saves the metadata we already know at creation time, periodt.

base_path = '/' — the base part of the URI for this resource.
allow_fetch = True — get operation? allowed, slay.
allow_commit = True — update operation? also allowed.
allow_head = True — head operation? you bet.
account_bytes_used — the total number of bytes stored in Object Storage for this account.
account_container_count — how many containers there are.
account_object_count — how many objects live in the account.
meta_temp_url_key — the secret key value for temporary URLs. If it's not set, this header just isn't returned by the operation. 🙈
meta_temp_url_key_2 — a second secret key value for temporary URLs. Same deal: not set = header not returned.
timestamp — the timestamp of the transaction. ⏰
requires_id = False — does this resource need an ID for its calls? No ma'am.

set_temp_url_key(session, key, secondary=False)

Sets the temporary url key for the account. 🔑

Parameters

session — the adapter to use for making this request.
key — the text of the key to use.
secondary — whether this should set the secondary key (defaults to False).

🧺 `openstack.object_store.v1.container`

✨ The Container Class ✨ — inherits from Resource (see <#openstack.resource.Resource>).

class openstack.object_store.v1.container.Container(metadata=None, **attrs)

Processes and saves the metadata known at creation stage.

base_path = '/' — the base part of the URI for this resource.
pagination_key = 'X-Account-Container-Count' — the key used for pagination links.
allow_create = True — creating? green light.
allow_fetch = True — fetching? green light.
allow_commit = True — updating? green light.
allow_delete = True — deleting? green light.
allow_list = True — listing? green light.
allow_head = True — heading? green light. The whole traffic system said yes 🚦
name — the name of the container.
count — how many objects are in the container.
bytes — the total number of bytes stored in Object Storage for the container.
object_count — the number of objects.
bytes_used — the count of bytes used in total.
timestamp — the timestamp of the transaction.
is_newest — if set to True, Object Storage queries all replicas to return the most recent one. If you omit this header, Object Storage responds faster once it finds one valid replica. Because setting this to True is more expensive for the back end, use it only when it is absolutely needed. Type: bool.
read_ACL — the ACL that grants read access. If it's not set, this header isn't returned by the operation.
write_ACL — the ACL that grants write access. Same thing: not set, not returned.
sync_to — the destination for container synchronization. Not set? Not returned, bestie.
sync_key — the secret key for container synchronization. Also not returned when unset.
versions_location — enables versioning on this container. The value is the name of another container. You must UTF-8-encode and then URL-encode the name before you include it in the header. To disable versioning, set the header to an empty string. ⚠️ Do the encoding, fr fr.
history_location — enables versioning on the container.
content_type — the MIME type of the list of names.
is_content_type_detected — if set to true, Object Storage guesses the content type based on the file extension and ignores whatever was sent in the Content-Type header, if present. Type: bool.
storage_policy — the storage policy used by the container. Heads up: it is not possible to change the policy of an existing container. Choose once, choose well 💀
if_none_match — in combination with Expect: 100-Continue, specify an "If-None-Match: *" header to query whether the server already has a copy of the object before any data is sent.
meta_temp_url_key — the secret key value for temporary URLs. If not set, this header isn't returned by the operation.
meta_temp_url_key_2 — a second secret key value for temporary URLs. Also not returned when unset.

classmethod new(**kwargs)

Creates a new instance of this resource. 🎀

When creating the instance, set the _synchronized parameter of Resource to False to say "hey, this resource does not exist on the server side yet." That marks every attribute passed in **attrs as "dirty" on the resource, and thereforely tracks them as necessary in subsequent calls like update(). Lowkey important.

Parameters

attrs — each of the named arguments will be set as attributes on the resulting Resource object. These should correspond to either Body or Header values on this resource.

set_temp_url_key(session, key, secondary=False)

Sets the temporary url key for a container. 🔐

Parameters

session — the session to use for making this request.
container — the value can be the name of a container or a Container instance.
key — the text of the key to use.
secondary — whether this should set the second key (defaults to False).

📦 `openstack.object_store.v1.obj`

✨ The Object Class ✨ — inherits from Resource (check <#openstack.resource.Resource>).

class openstack.object_store.v1.obj.Object(data=None, **attrs)

Processes and saves the metadata known at creation stage.

base_path = '/%(container)s' — the base part of the URI for this resource.
pagination_key = 'X-Container-Object-Count' — the key used for pagination links.
allow_create = True — creation: allowed.
allow_fetch = True — fetching: allowed.
allow_commit = True — updating: allowed.
allow_delete = True — deletion: allowed.
allow_list = True — listing: allowed.
allow_head = True — heading: allowed. Iconic behaviour only. 👑
container — the unique name for the container.
name — the unique name for the object.
is_newest — if set to True, Object Storage queries all replicas to return the most recent one. If you omit this header, Object Storage responds faster after it finds one valid replica. Because setting this header to True is more expensive for the back end, use it only when it's absolutely needed. Type: bool.
range — TODO(briancurtin) there's a lot of content here... 😭 (yes that's literally the note, we don't make the rules)
if_match — see <http://www.ietf.org/rfc/rfc2616.txt>.
if_none_match — in combination with Expect: 100-Continue, specify an "If-None-Match: *" header to query whether the server already has a copy of the object before any data is sent.
if_modified_since — see <http://www.ietf.org/rfc/rfc2616.txt>.
if_unmodified_since — see <http://www.ietf.org/rfc/rfc2616.txt>.
signature — used with temporary URLs to sign the request. For more info about temporary URLs, see OpenStack Object Storage API v1 Reference.
expires_at — used with temporary URLs to specify the expiry time of the signature. For more info about temporary URLs, see OpenStack Object Storage API v1 Reference.
manifest — if present, this is a dynamic large object manifest object. The value is the container and object name prefix of the segment objects, in the form container/prefix. 🦋
multipart_manifest — okay so if you include the multipart-manifest=get query parameter and the object is a large object, you do not get the object contents back. Instead, the manifest is returned in the X-Object-Manifest response header for dynamic large objects, or in the response body for static large objects. ✨
content_length — lowkey important: HEAD operations do not return content. However, in this operation the value in the Content-Length header is not the size of the response body. Instead it contains the size of the object, in bytes.
content_type — the MIME type of the object. 💅
accept_ranges — the type of ranges that the object accepts.
etag — bestie, listen. For objects smaller than 5 GB, this value is the MD5 checksum of the object content. The value is not quoted. For manifest objects, this value is the MD5 checksum of the concatenated string of MD5 checksums and ETags for each of the segments in the manifest, and not the MD5 checksum of the content that was downloaded. Also the value is enclosed in double-quote characters. You are strongly recommended to compute the MD5 checksum of the response body as it is received and compare this value with the one in the ETag header. If they differ, the content was corrupted, so retry the operation. 😭
is_static_large_object — set to True if this object is a static large object manifest object. Type: bool. 🫶
content_encoding — if set, the value of the Content-Encoding metadata. If not set, this header is not returned by this operation.
content_disposition — if set, specifies the override behavior for the browser. For example, this header might specify that the browser use a download program to save this file rather than show the file, which is the default. If not set, this header is not returned by this operation.
delete_after — specifies the number of seconds after which the object is removed. Internally, the Object Storage system stores this value in the X-Delete-At metadata item. ⏳
delete_at — if set, the time when the object will be deleted by the system in the format of a UNIX Epoch timestamp. If not set, this header is not returned by this operation.
object_manifest — if set, this is a dynamic large object manifest object. The value is the container and object name prefix of the segment objects in the form container/prefix.
timestamp — the timestamp of the transaction.
last_modified_at — the date and time that the object was created or the last time that the metadata was changed.
transfer_encoding — set to chunked to enable chunked transfer encoding. If used, do not set the Content-Length header to a non-zero value.
is_content_type_detected — if set to true, Object Storage guesses the content type based on the file extension and ignores the value sent in the Content-Type header, if present. Type: bool.
copy_from — if set, this is the name of an object used to create the new object by copying the X-Copy-From object. The value is in form {container}/{object}. You must UTF-8-encode and then URL-encode the names of the container and object before you include them in the header. Using PUT with X-Copy-From has the same effect as using the COPY operation to copy an object. 🔥
symlink_target — if present, this is a symlink object. The value is the relative path of the target object in the format <container>/<object>.
symlink_target_account — if present, and X-Symlink-Target is present, then this is a cross-account symlink to an object in the account specified in the value.
access_control_allow_origin — CORS for RAX (deviating from standard). That’s the whole note, no cap. 🌈

🛠️ `create(session, prepend_key=True, base_path=None, **params)`

Create a remote resource based on this instance. 💖

Parameters

session — the session to use for making this request.
prepend_key — DEPRECATED Configure create_opts instead. Whether the resource_key should be prepended in a resource creation request. Default to True.
base_path — base part of the URI for creating resources, if different from base_path <#openstack.resource.Resource.base_path>.
resource_request_key — DEPRECATED Configure create_opts instead. Overrides the usage of resource_key <#openstack.resource.Resource.resource_key> when prepending a key to the request body. Ignored if prepend_key is false.
resource_response_key — DEPRECATED Configure create_opts instead. Overrides the usage of resource_key <#openstack.resource.Resource.resource_key> when processing response bodies. Ignored if prepend_key is false.
microversion — API version to override the negotiated one.
params — additional params to pass.

Returns

This Resource instance. 🎀

Raises

MethodNotSupported <#openstack.exceptions.MethodNotSupported> if Resource.allow_create is not set to True.

🌸 Placement v1 Resources

🧚 `openstack.placement.v1.allocation`

The Allocation Class

The Allocation class inherits from Resource <#openstack.resource.Resource>. 🫶

class openstack.placement.v1.allocation.Allocation(_synchronized=False, connection=None, **attrs)

Allocations for a single consumer.

Allocations are records representing resources that have been assigned and used by a consumer of those resources. The consumer is identified by its UUID, which serves as the resource ID in the URL (/allocations/{consumer_uuid}).

An allocation maps resource providers to the resources consumed from them. Each entry in the allocations dict is keyed by resource provider UUID and contains a resources sub-dict mapping resource class names to quantities.

The base resource.

Parameters

_synchronized — this is not intended to be used directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.
resource_key = None — singular form of key for resource.
resources_key = None — plural form of key for resource.
base_path = '/allocations' — the base part of the URI for this resource.
allow_fetch = True — allow get operation for this resource.
allow_commit = True — allow update operation for this resource.
allow_delete = True — allow delete operation for this resource.
allocations — a dictionary of resource allocations keyed by resource provider UUID. Each value is a dict with a resources key mapping resource class names to quantities, e.g. {"DISK_GB": 4, "VCPU": 2}. Setting this to an empty dict removes all allocations for the consumer. 💀
consumer_generation — the generation of the consumer. Should be set to None when indicating that the caller expects the consumer does not yet exist.
consumer_type — a string that consists of numbers, A-Z, and _ describing what kind of consumer is creating, or has created, allocations using a quantity of inventory. The string is determined by the client when writing allocations and it is up to the client to ensure correct choices amongst collaborating services. For example, the compute service may choose to type some consumers 'INSTANCE' and others 'MIGRATION'.
project_id — the UUID of a project.
user_id — the UUID of a user.

🎀 `classmethod set(session, allocations)`

Set allocations for multiple consumers in a single atomic request. ✨

Parameters

session — the session to use for making this request.
allocations — a dict keyed by consumer UUID; see set_allocations() for the expected structure of each value.

Raises

ConflictException <#openstack.exceptions.ConflictException> if any resource provider or consumer generation does not match, or if there is insufficient inventory. 😭

🦋 `openstack.placement.v1.allocation_candidate`

The AllocationCandidate Class

The AllocationCandidate class inherits from Resource <#openstack.resource.Resource>. 💜

class openstack.placement.v1.allocation_candidate.AllocationCandidate(_synchronized=False, connection=None, **attrs)

A single candidate set of allocations.

Represents one entry from allocation_requests in the placement allocation candidates response, with the corresponding provider_summaries data filtered to only the resource providers referenced by this candidate. 🌟

An AllocationCandidate contains enough info to fire off an update_allocation() call: the allocations dict maps resource provider UUIDs → the resources you're requesting from each one, and provider_summaries hands you the capacity + trait deets for those providers so you can actually pick between candidates. 💅

The base resource ✨

Parameters

_synchronized — bestie do NOT use this directly, fr. See new() and existing().
connection — reference to the Connection being used. Defaults to None so Resource objects can exist without a live Connection (think unit tests). Any use of self._connection in Resource code should guard itself with a None check. 🫶

resource_key = None — singular form of the key for this resource.

resources_key = None — plural form of the key for this resource.

base_path = '/allocation_candidates' — the base part of the URI for this resource.

requires_id = False — do calls for this resource require an ID? (Nope, not this one.)

allow_list = True — list operation is allowed for this resource. 👑

mappings — a dict mapping request-group suffixes → the list of resource provider UUIDs that satisfy that group. Available from microversion 1.34.

provider_summaries — a dict keyed by resource provider UUID, holding capacity + trait info for each provider referenced in allocations. This is derived from the top-level provider_summaries field in the API response, filtered down to only the providers relevant to this candidate. 🎀

classmethod list(session, paginated=True, base_path=None, allow_unknown_params=False, *, microversion=None, **params)

This method is a generator which yields resource objects. ✨

It's a re-implementation of list() that handles the allocation candidates response format. The API returns a single dict with allocation_requests (a list) and provider_summaries (a shared dict keyed by resource provider UUID). This method yields one AllocationCandidate per entry in allocation_requests, with provider_summaries filtered to only the resource providers referenced by that candidate.

Head over to list() for the full docs — parameters, exceptions, return types, the whole thing. 📚

🌸 `openstack.placement.v1.resource_class` 🌸

The ResourceClass Class

The ResourceClass class inherits from Resource.

class openstack.placement.v1.resource_class.ResourceClass(_synchronized=False, connection=None, **attrs)

The base resource 💖

Parameters

_synchronized — not meant for direct use, bestie. See new() and existing().
connection — reference to the Connection being used. Defaults to None so Resource objects can be used without an active Connection, like in unit tests. Use of self._connection in Resource code should protect itself with a None check.

resource_key = None — singular form of key for resource.

resources_key = 'resource_classes' — plural form of key for resource.

base_path = '/resource_classes' — the base part of the URI for this resource.

allow_create = True — create operation allowed.

allow_fetch = True — get operation allowed.

allow_commit = True — update operation allowed.

allow_delete = True — delete operation allowed.

allow_list = True — list operation allowed. 🦋

allow_empty_commit = True — commits happen even without header or body being dirty.

name — the name of this resource. 💫

👑 `openstack.placement.v1.resource_provider` 👑

The ResourceProvider Class

The ResourceProvider class inherits from Resource.

class openstack.placement.v1.resource_provider.ResourceProvider(_synchronized=False, connection=None, **attrs)

The base resource ✨

Parameters

_synchronized — not for direct use, see new() and existing().
connection — reference to the Connection being used. Defaults to None so Resource objects work without an active Connection, e.g. in unit tests. Use of self._connection in Resource code should protect itself with a None check.

resource_key = None — singular form of key for resource.

resources_key = 'resource_providers' — plural form of key for resource.

base_path = '/resource_providers' — the base part of the URI for this resource.

allow_create = True — create operation allowed.

allow_fetch = True — get operation allowed.

allow_commit = True — update operation allowed.

allow_delete = True — delete operation allowed.

allow_list = True — list operation allowed. 🌈

aggregates — Aggregates.

id — the UUID of a resource provider.

generation — a consistent view marker that assists with managing concurrent resource provider updates. 🎀

links — links pertaining to this flavor. It's a list of dictionaries, each including the keys href and rel.

name — the name of this resource provider.

parent_provider_id — the UUID of the immediate parent of the resource provider.

root_provider_id — read-only UUID of the top-most provider in this provider tree.

usages — Resource class usage counts for this resource provider. 💜

commit(session, prepend_key=True, has_body=True, retry_on_conflict=None, base_path=None, *, microversion=None, **kwargs)

Commit the state of the instance to the remote resource.

Parameters

session — the session to use for making this request.
prepend_key — whether the resource_key should be prepended in a resource creation request. Defaults to True.
retry_on_conflict — whether to enable retries on HTTP CONFLICT (409). A value of None leaves the Adapter defaults.
base_path — base part of the URI for modifying resources, if different from base_path.
microversion — API version to override the negotiated one.
attrs — attributes to pass when updating the resource. These should correspond to either Body or Header values on the resource.

Returns — this Resource instance.

Raises MethodNotSupported if Resource.allow_commit is not set to True. 😭

set_inventories(session, inventories, resource_provider_generation)

Replace ALL the inventory records for the resource provider. Like, all of them. 🫶

Parameters

session — the session to use for making this request.
inventories — a dict mapping resource class names → inventory configuration dicts. Pass an empty dict to remove all inventories.
resource_provider_generation — the generation of the resource provider; used to detect concurrent updates.

Returns — the resource provider with the updated generation.

Raises ConflictException if the generation doesn't match, or if there are active allocations against an inventory being removed. ⚠️

delete_inventories(session)

Delete all inventory records for the resource provider.

Parameters

session — the session to use for making this request.

Raises ConflictException if there are active allocations against the resource provider. 💀

fetch_usages(session)

Fetch resource usage counts for the resource provider.

Parameters

session — the session to use for making this request.

Returns — the resource provider with usages populated. ✨

fetch_aggregates(session)

List aggregates set on the resource provider.

Parameters

session — the session to use for making this request.

Returns — the resource provider with aggregates populated. 🌸

set_aggregates(session, aggregates=None)

Replaces aggregates on the resource provider.

Parameters

session — the session to use for making this request.

aggregates (list) — List of aggregates.

Returns: The resource provider with updated aggregates populated.

🦋 openstack.placement.v1.resource_provider_allocation

The ResourceProviderAllocation Class

The ResourceProviderAllocation class inherits from Resource (the openstack.resource.Resource one, iykyk).

class openstack.placement.v1.resource_provider_allocation.ResourceProviderAllocation(_synchronized=False, connection=None, **attrs)

The base resource — that’s literally what it is, bestie.

Parameters

_synchronized — This is not intended to be used directly. See new() (openstack.resource.Resource.new) and existing() (openstack.resource.Resource.existing).
connection — Reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.
resource_key = None — Singular form of key for resource.
resources_key = None — Plural form of key for resource.
base_path = '/resource_providers/%(resource_provider_id)s/allocations' — The base part of the URI for this resource.
allow_list = True — Allow list operation for this resource.
resource_provider_id — The UUID of a resource provider.
consumer_id — The UUID of the consumer.
resource_provider_generation — A consistent view marker that assists with the management of concurrent resource provider updates.
consumer_generation — The generation of the consumer. Available from microversion 1.28.
resources — A dictionary of resource class names to the amount allocated to this consumer from this resource provider.

classmethod list(session, paginated=True, base_path=None, allow_unknown_params=False, *, microversion=None, **params)

This method is a generator which yields resource objects.

A re-implementation of list() (the openstack.resource.Resource.list one) that handles placement's single, unpaginated list implementation.

Refer to list() (openstack.resource.Resource.list) for full documentation including parameter, exception and return type documentation.

🌈 openstack.placement.v1.resource_provider_inventory

The ResourceProviderInventory Class

The ResourceProviderInventory class inherits from Resource (the openstack.resource.Resource one).

class openstack.placement.v1.resource_provider_inventory.ResourceProviderInventory(_synchronized=False, connection=None, **attrs)

The base resource — yes, base resource energy.

Parameters

_synchronized — This is not intended to be used directly. See new() (openstack.resource.Resource.new) and existing() (openstack.resource.Resource.existing).
connection — Reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.
resource_key = None — Singular form of key for resource.
resources_key = None — Plural form of key for resource.
base_path = '/resource_providers/%(resource_provider_id)s/inventories' — The base part of the URI for this resource.
allow_create = True — Allow create operation for this resource.
allow_fetch = True — Allow get operation for this resource.
allow_commit = True — Allow update operation for this resource.
allow_delete = True — Allow delete operation for this resource.
allow_list = True — Allow list operation for this resource.
resource_provider_id — The UUID of a resource provider.
resource_class — The name of the resource class.
resource_provider_generation — A consistent view marker that assists with the management of concurrent resource provider updates.
allocation_ratio — It is used in determining whether consumption of the resource of the provider can exceed physical constraints.
max_unit — A maximum amount any single allocation against an inventory can have.
min_unit — A minimum amount any single allocation against an inventory can have.
reserved — The amount of the resource a provider has reserved for its own use.
step_size — A representation of the divisible amount of the resource that may be requested. For example, step_size = 5 means that only values divisible by 5 (5, 10, 15, etc.) can be requested.
total — The actual amount of the resource that the provider can accommodate.

commit(session, prepend_key=True, has_body=True, retry_on_conflict=None, base_path=None, *, microversion=None, **kwargs)

Commit the state of the instance to the remote resource.

Parameters

session — The session to use for making this request.
prepend_key — Whether the resource_key (openstack.resource.Resource.resource_key) should be prepended in a resource creation request. Default to True.
retry_on_conflict — Whether to enable retries on HTTP CONFLICT (409). Value of None leaves the Adapter defaults.
base_path — Base part of the URI for modifying resources, if different from base_path (openstack.resource.Resource.base_path).
microversion — API version to override the negotiated one.
attrs — Attributes to pass when updating the resource. These should correspond to either Body or Header values on the resource.

Returns: This Resource instance.

Raises MethodNotSupported (openstack.exceptions.MethodNotSupported) if Resource.allow_commit is not set to True.

classmethod list(session, paginated=True, base_path=None, allow_unknown_params=False, *, microversion=None, **params)

This method is a generator which yields resource objects.

A re-implementation of list() (the openstack.resource.Resource.list one) that handles placement's single, unpaginated list implementation.

Refer to list() (openstack.resource.Resource.list) for full documentation including parameter, exception and return type documentation.

💜 openstack.placement.v1.resource_provider_trait

The ResourceProviderTrait Class

The ResourceProviderTrait class inherits from Resource (the openstack.resource.Resource one).

class openstack.placement.v1.resource_provider_trait.ResourceProviderTrait(_synchronized=False, connection=None, **attrs)

The base resource — base resource, no cap.

Parameters

_synchronized — This is not intended to be used directly. See new() (openstack.resource.Resource.new) and existing() (openstack.resource.Resource.existing).
connection — Reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.
resource_key = None — Singular form of key for resource.
resources_key = None — Plural form of key for resource.
base_path = '/resource_providers/%(resource_provider_id)s/traits' — The base part of the URI for this resource.
requires_id = False — Do calls for this resource require an ID.
commit_method = 'PUT' — Method for committing a resource. This must be PATCH if allow_patch is True.
allow_fetch = True — Allow get operation for this resource.
allow_commit = True — Allow update operation for this resource.
allow_delete = True — Allow delete operation for this resource.
resource_provider_id — The UUID of a resource provider.
resource_provider_generation — A consistent view marker that assists with the management of concurrent resource provider updates.
traits — Traits.

commit(session, prepend_key=True, has_body=True, retry_on_conflict=None, base_path=None, *, microversion=None, **kwargs)

Commit the state of the instance to the remote resource.

Parameters

session — The session to use for making this request.
prepend_key — Whether the resource_key (openstack.resource.Resource.resource_key) should be prepended in a resource creation request. Default to True.
retry_on_conflict — Whether to enable retries on HTTP CONFLICT (409). Value of None leaves the Adapter defaults.
base_path — Base part of the URI for modifying resources, if different from base_path (openstack.resource.Resource.base_path).
microversion — API version to override the negotiated one.
attrs — the attributes you're passing when you update the resource. These bad boys should line up with either Body or Header values on the resource. no random extras, bestie 🎀

Returns

This Resource instance. same one, freshly updated 💅

Raises MethodNotSupported if Resource.allow_commit is not set to True. so if that flag's off, it's giving forbidden energy and nothing happens 😭

fetch(session, requires_id=False, base_path=None, error_message=None, skip_cache=False, *, resource_response_key=None, microversion=None, **params)

Grab a remote resource based on this instance. like, go get it ✨

Parameters

session — the session you're using to make this request.
requires_id — whether the resource ID should be part of the requested URI.
base_path — the base part of the URI for fetching resources, in case it's different from base_path on Resource.
error_message — an error message that gets returned if the object you asked for doesn't exist.
skip_cache — a boolean, and it says whether the optional API cache should be skipped for this particular invocation.
resource_response_key — overrides how self.resource_key is used when processing the response body.
microversion — the API version to override the negotiated one with.
params — extra parameters that can be consumed.

Returns

This Resource instance. 💖

Raises MethodNotSupported if Resource.allow_fetch is not set to True.

Raises NotFoundException if the resource was literally not found. gone, missing, not in the building 🙈

openstack.placement.v1.trait

The Trait Class

The Trait class inherits from Resource. family tree moment 🌸

class openstack.placement.v1.trait.Trait(_synchronized=False, connection=None, **attrs)

The base resource. yes, that's the whole description, and honestly? iconic 💅

Parameters

_synchronized — not intended to be used directly. go look at new() and existing() instead, bestie.
connection — reference to the Connection being used. Defaults to None so Resource objects can exist without an active Connection — like in unit tests. any use of self._connection inside Resource code should protect itself with a check for None. protective energy fr fr 🫶

resource_key = None — singular form of key for resource.

resources_key = None — plural form of key for resource.

base_path = '/traits' — the base part of the URI for this resource.

allow_create = True — allow create operation for this resource.

allow_fetch = True — allow get operation for this resource.

allow_delete = True — allow delete operation for this resource.

allow_list = True — allow list operation for this resource.

create_opts

CreateOpts(request_key=<Unset.UNSET: 'UNSET'>, response_key=<Unset.UNSET: 'UNSET'>, method='PUT', requires_id=<Unset.UNSET: 'UNSET'>, response_has_body=True)

Class-level configuration for the create operation. Subclasses can override this to set per-resource defaults without overriding create(). slay, no code duplication 🔥

name — the name of this resource.

create(session, prepend_key=True, base_path=None, *, microversion=None, **kwargs)

Create a remote resource based on this instance. make it exist ✨

Parameters

session — the session to use for making this request.
prepend_key — DEPRECATED, configure create_opts instead. whether the resource_key should be prepended in a resource creation request. Defaults to True.
base_path — base part of the URI for creating resources, if different from base_path on Resource.
resource_request_key — DEPRECATED, configure create_opts instead. overrides the usage of resource_key when prepending a key to the request body. ignored if prepend_key is false.
resource_response_key — DEPRECATED, configure create_opts instead. overrides the usage of resource_key when processing response bodies. ignored if prepend_key is false.
microversion — the API version to override the negotiated one with.
params — additional params to pass.

Returns

This Resource instance. 💜

Raises MethodNotSupported if Resource.allow_create is not set to True.

classmethod list(session, paginated=True, base_path=None, allow_unknown_params=False, *, microversion=None, **params)

Okay so this method is a generator that yields resource objects. 🦋

It's a re-implementation of list() that handles the list of strings (as opposed to a list of objects) that this call returns. different shape, same vibe.

Refer to list() for the full documentation, including parameter, exception and return type docs. iykyk 📚

openstack.placement.v1.usage

The Usage Class

The Usage class inherits from Resource. 🧚

class openstack.placement.v1.usage.Usage(_synchronized=False, connection=None, **attrs)

Resource usage for one consumer type within a project. it's giving receipts, but make them structured 💅

Represents one entry from the usages dict returned by GET /usages. Every entry is keyed by consumer type (e.g. INSTANCE, MIGRATION) and contains:

consumer_count — the number of consumers of that type with active allocations in the project.
resources — a dict of resource class name to total amount consumed across all consumers of that type.

Available from placement microversion 1.38. Call usages() to retrieve instances. note that, bestie, it's a real requirement ⭐

The base resource.

Parameters

_synchronized — not intended to be used directly. See new() and existing().
connection — reference to the Connection being used. Defaults to None so Resource objects can be used without an active Connection, like in unit tests. any use of self._connection in Resource code should protect itself with a check for None.

resource_key = None — singular form of key for resource.

resources_key = None — plural form of key for resource.

base_path = '/usages' — the base part of the URI for this resource.

requires_id = False — do calls for this resource require an ID. nope!

allow_list = True — allow list operation for this resource.

consumer_type — the consumer type string, e.g. INSTANCE or MIGRATION.

consumer_count — the number of consumers of this type with active allocations.

resources — a dict of resource class name to total amount consumed across all consumers of this type, e.g. {"VCPU": 2, "DISK_GB": 5}. 💖

classmethod list(session, paginated=True, base_path=None, allow_unknown_params=False, *, microversion=None, **params)

This method is a generator which yields resource objects. 🌈

It's a re-implementation of list() that handles the GET /usages response format. The API returns a single usages dict keyed by consumer type, and this method yields one Usage per entry, with the per-resource-class amounts packed into the resources field. unpacking the vibes, one entry at a time 🎀

Refer to list() for the full documentation, including parameter, exception and return type documentation.

Shared File System service resources

openstack.shared_file_system.v2.availability_zone

The AvailabilityZone Class

The AvailabilityZone class inherits from Resource. 💅

class openstack.shared_file_system.v2.availability_zone.AvailabilityZone(_synchronized=False, connection=None, **attrs)

The base resource.

Parameters

_synchronized — not intended to be used directly. See new() and existing().
connection — reference to the Connection being used. Defaults to None so Resource objects can be used without an active Connection, such as in unit tests. any use of self._connection in Resource code should protect itself with a check for None. 🫶

resource_key = 'availability_zone' — singular form of key for resource.

resources_key = 'availability_zones' — plural form of key for resource.

base_path = '/availability-zones' — the base part of the URI for this resource.

allow_create = False — allow create operation for this resource. nope, can't make these 💀

allow_fetch = False — allow get operation for this resource.

allow_commit = False — nope, this resource does not do updates. not today 💅
- allow_delete = False — and no deletes either, sorry bestie 🙈
- allow_list = True — listing though? yes bestie, list away ✨
- id — Properties. The ID of the availability zone 🆔
- name — the name of the availability zone 🏷️
- created_at — date and time the availability zone was created at ⏰
- updated_at — date and time the availability zone was last updated at 🔄

openstack.shared_file_system.v2.limit

The Limit Class 💀

The Limit class inherits from Resource <#openstack.resource.Resource>.

class openstack.shared_file_system.v2.limit.Limit(_synchronized=False, connection=None, **attrs)

The base resource 👑

Parameters

_synchronized — this is not intended to be used directly, okay? see new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing> 🫶
connection — reference to the Connection being used. Defaults to None so Resource objects can be used without an active Connection, like in unit tests, fr. Any use of self._connection in Resource code should protect itself with a check for None 🔥

resources_key = 'limits' — plural form of key for resource 📚

base_path = '/limits' — the base part of the URI for this resource 🛣️

allow_create = False — no creating this one 🙅‍♀️
allow_fetch = False — no fetching either 😭
allow_commit = False — no updating, not today 💅
allow_delete = False — no deleting, periodt ✋
allow_list = True — listing? absolutely, go off 👑
allow_head = False — head is a no 🚫

Then the properties, and there are so many of them:

maxTotalReplicaGigabytes — Properties. The maximum number of replica gigabytes that are allowed in a project 💾
maxTotalShares — the total maximum number of shares that are allowed in a project 📦
maxTotalShareGigabytes — the total maximum number of share gigabytes that are allowed in a project 💽
maxTotalShareNetworks — the total maximum number of share-networks that are allowed in a project 🌐
maxTotalShareSnapshots — the total maximum number of share snapshots that are allowed in a project 📸
maxTotalShareReplicas — the maximum number of share replicas that is allowed 🪞
maxTotalSnapshotGigabytes — the total maximum number of snapshot gigabytes that are allowed in a project 🗄️
totalReplicaGigabytesUsed — the total number of replica gigabytes used in a project by share replicas 📊
totalShareGigabytesUsed — the total number of gigabytes used in a project by shares 💿
totalSharesUsed — the total number of created shares in a project 🧮
totalShareNetworksUsed — the total number of created share-networks in a project 🕸️
totalShareSnapshotsUsed — the total number of created share snapshots in a project 🖼️
totalSnapshotGigabytesUsed — the total number of gigabytes used in a project by snapshots 💾
totalShareReplicasUsed — the total number of created share replicas in a project 🔁

openstack.shared_file_system.v2.quota_class_set

The QuotaClassSet Class 🎀

The QuotaClassSet class inherits from Resource <#openstack.resource.Resource> and can be used to query quota class 💖

class openstack.shared_file_system.v2.quota_class_set.QuotaClassSet(_synchronized=False, connection=None, **attrs)

The base resource 👑

Parameters

_synchronized — not intended to be used directly, bestie. see new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing> 🌸
connection — reference to the Connection being used. Defaults to None so Resource objects can be used without an active Connection, like in unit tests. Use of self._connection in Resource code should protect itself with a check for None 🫶

base_path = '/quota-class-sets' — the base part of the URI for this resource 🛣️

resource_key = 'quota_class_set' — singular form of key for resource 1️⃣

allow_create = False — no create 🙅‍♀️
allow_fetch = True — fetch? yes please ✨
allow_commit = True — commit/update, absolutely 💅
allow_delete = False — delete? nope 🙈
allow_list = False — no listing 😭
allow_head = False — and no head 🚫

Properties time ✨

id — Properties. A quota_class_set id 🆔
share_groups — the maximum number of share groups 👯
share_group_snapshots — the maximum number of share group snapshots 📸
snapshots — the total maximum number of shares that are allowed in a project (yes, that's exactly what it says 😭)
snapshot_gigabytes — the maximum number of snapshot gigabytes that are allowed in a project 💾
shares — the total maximum number of snapshot gigabytes that are allowed in a project (again — that's literally what the original says, i'm just the messenger 💀)
share_networks — the maximum number of share-networks that are allowed in a project 🌐
share_replicas — the maximum number of share replicas that is allowed 🪞
gigabytes — the total maximum number of share gigabytes that are allowed in a project. You cannot request a share that exceeds the allowed gigabytes quota ⚠️
replica_gigabytes — the maximum number of replica gigabytes that are allowed in a project. You cannot create a share, share replica, manage a share or extend a share if it is going to exceed the allowed replica gigabytes quota 🚨
per_share_gigabytes — the number of gigabytes per share allowed in a project 📏
backups — the total maximum number of share backups that are allowed in a project 🗂️
backup_gigabytes — the total maximum number of backup gigabytes that are allowed in a project 💽

openstack.shared_file_system.v2.quota__set

The QuotaSet Class 👑

The QuotaSet class inherits from Resource <#openstack.resource.Resource> and can be used to query quotas 💖

class openstack.shared_file_system.v2.quota_set.QuotaSet(_synchronized=False, connection=None, **attrs)

The base resource 🌟

Parameters

_synchronized — not intended to be used directly. see new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing> 🦋
connection — reference to the Connection being used. Defaults to None so Resource objects can be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None 🫶

resource_key = 'quota_set' — singular form of key for resource 1️⃣

resources_key = 'quota_sets' — plural form of key for resource 📚

base_path = '/quota-sets/%(project_id)s' — the base part of the URI for this resource 🛣️

allow_create = False — no create 🙅‍♀️
allow_list = False — no list 😭

Properties, get comfy 💅

gigabytes — Properties. The number of gigabytes allowed for each project 💾
snapshots — the number of snapshots allowed for each project 📸
shares — the number of shares allowed for each project 📦
snapshot_gigabytes — the number of gigabytes for the snapshots allowed for each project 💽
share_groups — the number of share groups allowed for each project or user 👯
share_group_snapshots — the number of share group snapshots allowed for each project or user 🖼️
share_networks — the number of share networks allowed for each project 🌐
share_replicas — the number of share replicas allowed for each project 🪞
replica_gigabytes — the number of gigabytes for the share replicas allowed for each project 💿
per_share_gigabytes — the number of gigabytes per share allowed for each project 📏
backups — the number of backups allowed for each project 🗂️
backup_gigabytes — the number of gigabytes for the backups allowed for each project 🧮

openstack.shared_file_system.v2.resource_locks

The Resource Locks Class 🔒

The ResourceLock class inherits from Resource <#openstack.resource.Resource>.

class openstack.shared_file_system.v2.resource_locks.ResourceLock(_synchronized=False, connection=None, **attrs)

The base resource 👑

Parameters

_synchronized — not intended to be used directly. see new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing> 🧚
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None 🫶

resource_key = 'resource_lock' — singular form of key for resource 1️⃣

resources_key = 'resource_locks' — plural form of key for resource 📚

base_path = '/resource-locks' — the base part of the URI for this resource, periodt.
allow_create = True — create is allowed for this resource, slay.
allow_fetch = True — fetching (get) is allowed 💖
allow_commit = True — update/commit is allowed ✨
allow_delete = True — delete is allowed, bye bestie 👋
allow_list = True — listing is allowed 🌸
allow_head = False — head is not allowed, nope 🙈
created_at — Properties field: the date and time stamp of when the resource got created inside the services's database 🕐
updated_at — the date and time stamp of when the resource was last modified inside the services's database 🕑
user_id — the ID of the user that owns the lock 👑
project_id — the ID of the project that owns the lock 🎀
resource_type — the type of the resource that is locked, i.e.: share, access rule.
resource_id — the UUID of the resource that's locked 🔒
resource_action — what action is currently locked, i.e.: deletion, visibility of fields.
lock_reason — the reason that was specified while the lock was being placed 📝
lock_context — the context that placed the lock (user, admin or service).

🧚 openstack.shared_file_system.v2.service

The Service Class ✨

Okay so the Service class inherits from Resource.

class openstack.shared_file_system.v2.service.Service(_synchronized=False,
connection=None, **attrs)

The literal base resource, no cap.

Parameters 🫶

_synchronized — not intended to be used directly, bestie. See new() and existing() instead. Skip it, iykyk.
connection — reference to the Connection being used. Defaults to None so Resource objects can still be used without an active Connection, like in unit tests. Any use of self._connection in Resource code should protect itself with a check for None. Cute and defensive, we love to see it 💅
resource_key = 'service' — singular form of the key for the resource.
resources_key = 'services' — plural form of the key for the resource.
base_path = '/services' — the base part of the URI for this resource.
allow_create = False — no creating here 🙅‍♀️
allow_fetch = False — no fetching either 🚫
allow_commit = True — but update? oh she's allowed ✨
allow_delete = False — delete is a no-go.
allow_list = True — listing is very much allowed 🌈
allow_head = False — head is not allowed, nope.
availability_zone — Properties field: the availability zone of the service 🌍
binary — the service binary name.
host — the service host name 🖥️
name — the service name 🏷️
state — the current state of the service.
status — the service status, which is enabled or disabled.
updated_at — the date and time stamp of when the resource was last updated within the service's database ⏰
disabled_reason — the reason for disabling the service 😭
ensuring — whether the service is currently ensuring shares.
enable(session) — enable the service 💖 she's back on.
disable(session, disable_reason=None) — disable the service 💀 mind the optional disable_reason.
ensure_shares(session) — ensure shares on a back end.

The Share class inherits from Resource.

class openstack.shared_file_system.v2.share.Share(_synchronized=False,
connection=None, **attrs)

Again, the base resource. Hi bestie.

Parameters

_synchronized — don't use this directly, literally. See new() and existing().
connection — reference to the Connection being used. Defaults to None so Resource objects work without an active Connection, e.g. in unit tests. Any self._connection use in Resource code should guard with a None check ✨
resource_key = 'share' — singular form of the key for the resource.
resources_key = 'shares' — plural form of the key for the resource.
base_path = '/shares' — the base part of the URI for this resource.
allow_create = True — yes create 💖
allow_fetch = True — yes fetch 🌸
allow_commit = True — yes update ✨
allow_list = True — yes list 🌈
allow_head = False — no head 🙈
allow_delete = True — yes delete 🔥
access_rules_status — Properties field: the share instance access rules status. A valid value is active, error, or syncing.
availability_zone — the availability zone 🌍
created_at — the date and time stamp of when the resource was created within the services's database 🕐
description — the user defined description of the resource 📝
host — the share host name 🖥️
is_public — the level of visibility for the share 👀
is_creating_new_share_from_snapshot_supported — whether or not this share supports snapshots that can be cloned into new shares 🧬
is_mounting_snapshot_supported — whether the share's snapshots can be mounted directly and access controlled independently or not 🔐
is_reverting_to_snapshot_supported — whether the share can be reverted to its latest snapshot or not ⏪
is_snapshot_supported — an extra specification that filters back ends by whether the share supports snapshots or not.
is_replicated — indicates whether the share has replicas or not 👯‍♀️
metadata — one or more metadata key and value pairs, as a dictionary of strings.
progress — the progress of the share creation 📈
project_id — the ID of the project that owns the resource 💜
replication_type — the share replication type. Valid values are none, readable, writable and dr.
share_group_id — the UUID of the share group that this share belongs to.
share_network_id — the share network ID.
share_protocol — the Shared File Systems protocol. A valid value is NFS, CIFS, GlusterFS, HDFS, CephFS, MAPRFS
share_server_id — the UUID of the share server.
share_type — the UUID of the share type. In minor versions, this parameter is a share type name, as a string. Chaotic but iconic.
share_type_name — name of the share type.
size — the share size, in GiBs 🍓
snapshot_id — the UUID of the snapshot that was used to create the share.
source_share_group_snapshot_member_id — the ID of the group snapshot instance that was used to create this share.
status — the share status 🚦
task_state — for the share migration, the migration task state.
user_id — ID of the user that the share was created by 👑
display_name — display name for updating name.
display_description — display description for updating description.
extend_share(session, new_size, force=False) — extend the share size, she's growing 💅

Parameters

session — a session object used for sending the request.
new_size — the new size of the share in GiB.
force — whether or not to use force, bypassing the scheduler. Requires admin privileges. Defaults to False. ⚠️ admin vibes only.

Returns The result of the action.

shrink_share(session, new_size) — shrink the share size, she's on a diet 🍃

Parameters

session — a session object used for sending the request.
new_size — the new size of the share in GiB.

Returns None

revert_to_snapshot(session, snapshot_id) — revert the share to the given snapshot ⏪✨

Parameters

session — a session object used for sending the request.
snapshot_id — the id of the snapshot to revert to.

Returns None

manage(session, protocol, export_path, service_host, **params) — manage a share 🎛️

Parameters

session — a session object used for sending the request.
protocol — the shared file systems protocol of this share.
export_path — the export path, formatted according to the protocol.
service_host — the manage-share service host.
params —

Optional parameters to be sent. Available parameters include:

name: the user defined name of the resource.

share_type — the name or ID of the share type you want to use to create the resource ✨
- driver_options — a set of one or more key and value pairs, as a dictionary of strings, that describe driver options. lowkey just a dict of strings, bestie 🫶
- is_public — the level of visibility for the share 👀
- description — the user defined description of the resource ✍️
- share_server_id — the UUID of the share server 🔑

Returns

The share that was managed. that's it, that's the return 💅

unmanage(session)

Unmanage a share. letting it go, free-range share era 🦋

Parameters

session — a session object used for sending request.

Returns

None

force_delete(session)

Force delete the share. no soft launch, we're going straight through the wall 💀

Returns

None

soft_delete(session)

Soft delete a share. gentle deletion, we love a respectful breakup 🌸

Parameters

session — a session object used for sending request.

Returns

None

restore(session)

Restore a share. bringing it back like nothing happened 😭

Parameters

session — a session object used for sending request.

Returns

None

reset_status(session, status)

Reset the share to the given status. factory reset but for a status field 👑

Parameters

status — the status of the share to reset to.

Returns

None

🌈 `openstack.shared_file_system.v2.share_access_rule`

The `ShareAccessRule` Class

The ShareAccessRule class inherits from Resource <#openstack.resource.Resource>. family tree moment 🧚

class openstack.shared_file_system.v2.share_access_rule.ShareAccessRule(_synchronized=False, connection=None, **attrs)

The base resource.

Parameters

_synchronized — this is not intended to be used directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>. don't touch it, i'm serious 🙈
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.

resource_key = 'access' — singular form of key for resource.

resources_key = 'access_list' — plural form of key for resource.

base_path = '/share-access-rules' — the base part of the URI for this resource.

allow_create = True — allow create operation for this resource.

allow_fetch = True — allow get operation for this resource.

allow_commit = False — allow update operation for this resource. nope, not allowed, read the room 💅

allow_delete = True — allow delete operation for this resource.

allow_list = True — allow list operation for this resource.

allow_head = False — allow head operation for this resource.

create_opts = CreateOpts(request_key='allow_access', response_key='access', method='POST', requires_id=<Unset.UNSET: 'UNSET'>, response_has_body=True)

Class-level configuration for the create operation. Subclasses can override this to set per-resource defaults without overriding create(). iconic inheritance behavior honestly 👑

access_key — Properties The access credential of the entity granted share access.

access_level — the access level to the share.

access_list — the object of the access rule.

access_to — the value that defines the access.

access_type — the access rule type.

created_at — the date and time stamp when the resource was created within the services's database. timestamp bestie ⭐

metadata — one or more access rule metadata key and value pairs as a dictionary of strings.

share_id — the UUID of the share to which you are granted or denied access. granted OR denied, both on the table 😤

state — the state of the access rule.

updated_at — the date and time stamp when the resource was last updated within the services's database.

lock_visibility — whether the visibility of some sensitive fields is restricted or not 🔒

lock_deletion — whether the deletion of the access rule should be restricted or not 🔒

lock_reason — reason for placing the loc.

delete(session, error_message=None, *, microversion=None, unrestrict=False, **kwargs)

Delete the remote resource based on this instance. bye bye bestie 👋

Parameters

session — the session to use for making this request.
microversion — API version to override the negotiated one.
base_path — base part of the URI for modifying resources, if different from base_path <#openstack.resource.Resource.base_path>.
params — query string parameters to include in the request URL.

Returns

This Resource instance. it hands itself back to you, main character energy ✨

Raises MethodNotSupported <#openstack.exceptions.MethodNotSupported> if Resource.allow_commit is not set to True.

Raises NotFoundException <#openstack.exceptions.NotFoundException> if the resource was not found.

💜 `openstack.shared_file_system.v2.share_group`

The `ShareGroup` Class

The ShareGroup class inherits from Resource <#openstack.resource.Resource>. squad goals 🫶

class openstack.shared_file_system.v2.share_group.ShareGroup(_synchronized=False, connection=None, **attrs)

The base resource.

Parameters

_synchronized — this is not intended to be used directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.

resource_key = 'share_group' — singular form of key for resource.

resources_key = 'share_groups' — plural form of key for resource.

base_path = '/share-groups' — the base part of the URI for this resource.

allow_create = True — allow create operation for this resource.

allow_fetch = True — allow get operation for this resource.

allow_commit = True — allow update operation for this resource. we CAN commit here, unlike the last one 💅

allow_delete = True — allow delete operation for this resource.

allow_list = True — allow list operation for this resource.

allow_head = False — allow head operation for this resource.

availability_zone — Properties The availability zone ID that the share group exists within.

consistent_snapshot_support — the consistency snapshot support.

created_at — the date and time stamp when the resource was created within the services's database.

description — the user defined description of the resource.

project_id — the ID of the project that owns the resource.

share_group_snapshot_id — the share group snapshot ID.

share_group_type_id — the share group type ID.

share_network_id — the share network ID where the resource is exported to.

share_types — a list of share type IDs.

status — the share status.

🦋 `openstack.shared_file_system.v2.share_group_snapshot`

The `ShareGroupSnapshot` Class

The ShareGroupSnapshot class inherits from Resource <#openstack.resource.Resource>. snapshot of the whole group, obsessed 📸

class openstack.shared_file_system.v2.share_group_snapshot.ShareGroupSnapshot(_synchronized=False, connection=None, **attrs)

The base resource.

Parameters

_synchronized — this is not intended to be used directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.

resource_key = 'share_group_snapshot' — singular form of key for resource.

resources_key = 'share_group_snapshots' — plural form of key for resource.

base_path = '/share-group-snapshots' — the base part of the URI for this resource.

allow_create = True — allow create operation for this resource.

allow_fetch = True — allow get operation for this resource.

allow_commit = True — allow update operation for this resource.

allow_delete = True — allow delete operation for this resource.

allow_list = True — allow list operation for this resource.

allow_head = False — allow head operation for this resource.

project_id — Properties The ID of the project that owns the resource.

status — filters by a share group snapshot status. a valid value is creating, error, available, deleting, error_deleting. those are the only options, don't freestyle it 😭

share_group_id — the UUID of the share group. like, the actual ID of the group it belongs to 🫶
description — the user-defined description of the resource. you write it, you own it 💅
created_at — the date + time stamp of when the resource was created ✨
members — the share group snapshot members. the whole squad 👑
size — the snapshot size, in GiBs.
share_protocol — NFS, CIFS, GlusterFS, HDFS, CephFS or MAPRFS.

`openstack.shared_file_system.v2.share_instance`

The ShareInstance Class — ok so this one inherits from Resource <#openstack.resource.Resource> 💖

class openstack.shared_file_system.v2.share_instance.ShareInstance(_synchronized=False, connection=None, **attrs)

The base resource

Parameters

_synchronized — not meant to be used directly, bestie. see new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
connection — a reference to the Connection being used. defaults to None so Resource objects can exist without an active Connection, like in unit tests. any use of self._connection in Resource code should protect itself with a check for None 🙈

resource_key = 'share_instance' — singular form of the key for the resource.

resources_key = 'share_instances' — plural form of the key for the resource.

base_path = '/share_instances' — the base part of the URI for this resource.

allow_create = False — allow create operation for this resource.

allow_fetch = True — allow get operation for this resource.

allow_commit = False — allow update operation for this resource.

allow_delete = False — allow delete operation for this resource.

allow_list = True — allow list operation for this resource.

allow_head = False — allow head operation for this resource.

access_rules_status — properties the share instance access rules status. a valid value is active, error, or syncing ⭐

availability_zone — the name of the availability zone the share exists within.

cast_rules_to_readonly — if the share instance has its cast_rules_to_readonly attribute set to True, all existing access rules get cast to read-only. no take-backsies 🔥

created_at — the date and time stamp when the resource was created within the service's database.

host — the host name of the service back end that the resource is contained within.

progress — the progress of the share creation. the way it's just a number that ticks up 😭

replica_state — the share replica state. only set to a value when replication is used. list of possible values: active, in_sync, out_of_sync, error.

share_id — the UUID of the share that the share instance belongs to.

share_network_id — the share network ID where the resource is exported to.

share_server_id — the UUID of the share server.

status — the share or share instance status.

reset_status(session, reset_status) — reset share instance to the given status.

force_delete(session) — force delete share instance. aggressive but iconic 💀

`openstack.shared_file_system.v2.share_network`

The ShareNetwork Class — inherits from Resource <#openstack.resource.Resource> 🦋

class openstack.shared_file_system.v2.share_network.ShareNetwork(_synchronized=False, connection=None, **attrs)

The base resource

Parameters

_synchronized — not intended to be used directly. see new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
connection — reference to the Connection being used. defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. use of self._connection in Resource code should protect itself with a check for None 🌸

resource_key = 'share_network' — singular form of key for resource.

resources_key = 'share_networks' — plural form of key for resource.

base_path = '/share-networks' — the base part of the URI for this resource.

allow_create = True — allow create operation for this resource.

allow_fetch = True — allow get operation for this resource.

allow_commit = True — allow update operation for this resource.

allow_delete = True — allow delete operation for this resource.

allow_list = True — allow list operation for this resource.

allow_head = False — allow head operation for this resource.

created_at — properties the date and time stamp when the resource was created within the service's database.

description — the user-defined description of the resource.

project_id — the ID of the project that owns the resource. yours truly 💅

share_network_subnets — a list of share network subnets that pertain to the related share network.

neutron_net_id — the UUID of a neutron network when setting up or updating a share network subnet with neutron.

neutron_subnet_id — the UUID of the neutron subnet when setting up or updating a share network subnet with neutron.

updated_at — the date and time stamp when the resource was last updated within the service's database.

`openstack.shared_file_system.v2.share_network_subnet`

The ShareNetworkSubnet Class — inherits from Resource <#openstack.resource.Resource> 🧚

class openstack.shared_file_system.v2.share_network_subnet.ShareNetworkSubnet(_synchronized=False, connection=None, **attrs)

The base resource

Parameters

_synchronized — this is not intended to be used directly. see new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
connection — reference to the Connection being used. defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. use of self._connection in Resource code should protect itself with a check for None 🎀

resource_key = 'share_network_subnet' — singular form of key for resource.

resources_key = 'share_network_subnets' — plural form of key for resource.

base_path = '/share-networks/%(share_network_id)s/subnets' — the base part of the URI for this resource.

allow_create = True — allow create operation for this resource.

allow_fetch = True — allow get operation for this resource.

allow_commit = False — allow update operation for this resource.

allow_delete = True — allow delete operation for this resource.

allow_list = True — allow list operation for this resource.

create_opts = CreateOpts(request_key='share-network-subnet', response_key=<Unset.UNSET: 'UNSET'>, method='POST', requires_id=<Unset.UNSET: 'UNSET'>, response_has_body=True) — class-level configuration for the create operation. subclasses can override this to set per-resource defaults without overriding create() ✨

share_network_id — properties the share network ID, part of the URI for share network subnets.

availability_zone — the name of the availability zone that the share network subnet belongs to.

cidr — the IP block from which to allocate the network, in CIDR notation.

created_at — date and time the share network subnet was created at.

gateway — the gateway of a share network subnet.

ip_version — the IP version of the network.

mtu — the MTU of a share network subnet.

network_type — the network type. a valid value is VLAN, VXLAN, GRE, or flat ⭐

neutron_net_id — the name of the neutron network.

neutron_subnet_id — the ID of the neutron subnet.

segmentation_id — the segmentation ID.

share_network_name — the name of the share network that the share network subnet belongs to.

updated_at — date and time the share network subnet was last updated at.

`openstack.shared_file_system.v2.share_replica`

The ShareReplica Class — inherits from Resource <#openstack.resource.Resource> 🌈

class openstack.shared_file_system.v2.share_replica.ShareReplica(_synchronized=False, connection=None, **attrs)

The base resource

Parameters

_synchronized — this is not intended to be used directly. see new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
connection — reference to the Connection being used. defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. use of self._connection in Resource code should protect itself with a check for None 💜

resource_key = 'share_replica' — singular form of key for resource.

resources_key = 'share_replicas' — plural form of key for resource.

base_path = 'share-replicas' — the base part of the URI for this resource.

allow_create = True — allow create operation for this resource.

allow_fetch = True — allow get operation for this resource.

allow_commit = False — nope, you can't update this one. Read-only vibes.
allow_delete = True — delete? absolutely, go off 💅
allow_list = True — you can list these, slay
allow_head = False — no head requests, sorry bestie
share_id — properties The UUID of the share from which to create a share replica. literally the origin story.
status — The status of a share replica. List of possible values: <rainbow>available, error, creating, deleting, or error_deleting</rainbow>.
cast_rules_to_readonly — If the share replica has its cast_rules_to_readonly attribute set to True, all existing access rules will be cast to read/only. 🫶
updated_at — The date and time stamp when the resource was last updated within the service's database. If a resource was never updated after it was created, the value of this parameter is set to null. as it should be ✨
share_network_id — The share network ID where the resource is exported to.
share_server_id — The UUID of the share server.
host — The host name of the share replica.
replica_state — The replica state of a share replica.
created_at — The date and time stamp when the resource was created within the service's database.
reset_status(session, status) — Reset the status of the share replica. fresh start energy 🦋
reset_replica_state(session, replica_state) — Reset replica_state of the share replica.
force_delete(session, *, ignore_missing=False) — Force-delete share replica. no cap, it's gone 💀
promote(session) — Promote share replica. main character promotion arc 👑
resync(session) — Resync share replica.

The ShareSnapshot Class

The ShareSnapshot class inherits from Resource <#openstack.resource.Resource>.

class openstack.shared_file_system.v2.share_snapshot.ShareSnapshot(_synchronized=False, connection=None, **attrs)

The base resource

Parameters

_synchronized — This is not intended to be used directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
connection — Reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.

Then the class attributes:

resource_key = 'snapshot' — Singular form of key for resource.
resources_key = 'snapshots' — Plural form of key for resource.
base_path = '/snapshots' — The base part of the URI for this resource.
allow_create = True — Allow create operation for this resource. ✨
allow_fetch = True — Allow get operation for this resource.
allow_commit = True — Allow update operation for this resource.
allow_delete = True — Allow delete operation for this resource.
allow_list = True — Allow list operation for this resource.
allow_head = False — Allow head operation for this resource.
created_at — Properties The date and time stamp when the resource was created within the services's database.
description — The user defined description of the resource.
display_name — The user defined name of the resource.
display_description — The user defined description of the resource
project_id — ID of the project that the snapshot belongs to.
share_id — The UUID of the source share that was used to create the snapshot.
share_proto — The file system protocol of a share snapshot
share_size — The snapshot's source share's size, in GiBs.
size — The snapshot size, in GiBs.
status — The snapshot status
user_id — ID of the user that the snapshot was created by.
reset_status(session, status) — Reset the snapshot to the given status.

Parameters

status — The status of the share to reset to.

Returns None

force_delete(session) — Force delete the snapshot. 😤

Returns None

manage(session, share_id, provider_location, **params) — Manage a share snapshot.

Parameters

session — A session object used for sending request.
share_id — The UUID of the share that has snapshot which should be managed.
provider_location — Provider location of the snapshot on the backend.
params —

Optional parameters to be sent. Available parameters include:

name: The user defined name of the resource.
display_name: The user defined name of the resource. This field sets the name parameter.
description: The user defined description of the resource.
display_description: The user defined description of the resource. This field sets the description parameter.
driver_options: A set of one or more key and value pairs, as a dictionary of strings, that describe driver options.

Returns The share snapshot that was managed. 🎀

unmanage(session) — Unmanage a share snapshot.

Parameters session — A session object used for sending request.

Returns None

The ShareSnapshotInstance Class

The ShareSnapshotInstance class inherits from Resource <#openstack.resource.Resource>.

class openstack.shared_file_system.v2.share_snapshot_instance.ShareSnapshotInstance(_synchronized=False, connection=None, **attrs)

The base resource

Parameters

_synchronized — This is not intended to be used directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
connection — Reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.

Attributes, coming right up:

resource_key = 'snapshot_instance' — Singular form of key for resource.
resources_key = 'snapshot_instances' — Plural form of key for resource.
base_path = '/snapshot-instances' — The base part of the URI for this resource.
allow_create = False — Allow create operation for this resource. not happening 🙈
allow_fetch = True — Allow get operation for this resource.
allow_commit = False — Allow update operation for this resource.
allow_delete = False — Allow delete operation for this resource.
allow_list = True — Allow list operation for this resource.
allow_head = False — Allow head operation for this resource.
created_at — Properties The date and time stamp when the resource was created within the services's database.
progress — The progress of the snapshot creation. we're getting there bestie 🫶
provider_location — Provider location of the snapshot on the backend.
share_id — The UUID of the share.
share_instance_id — The UUID of the share instance.
snapshot_id — The UUID of the snapshot.
status — The snapshot instance status.
updated_at — The date and time stamp when the resource was updated within the services's database.

The ShareTransfer Class

The ShareTransfer class inherits from Resource <#openstack.resource.Resource> and can be used to query quota class

class openstack.shared_file_system.v2.share_transfer.ShareTransfer(_synchronized=False, connection=None, **attrs)

The base resource

Parameters

_synchronized — This is not intended to be used directly. See new() <#openstack.resource.Resource.new> and existing() <#openstack.resource.Resource.existing>.
connection — Reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests. Use of self._connection in Resource code should protect itself with a check for None.
resource_key = 'transfer' — Singular form of key for resource.
base_path = '/share-transfers' — The base part of the URI for this resource.
allow_list = True — Allow list operation for this resource.
allow_create = True — Allow create operation for this resource. ⭐
allow_fetch = True — Allow get operation for this resource.
allow_commit = False — Allow update operation for this resource.
allow_delete = True — Allow delete operation for this resource.
allow_head = False — Allow head operation for this resource.
id — The transfer UUID.
share_id — The share UUID.
created_at — the date + time stamp of when this resource got created in the service's database 🕐
name — the display name of the transfer, bestie 💖
resource_type — what type of resource we're transferring.
resource_id — the UUID of the resource being transferred 🔑
auth_key — the authentication key for the transfer (the magic password, basically 🔮)
source_project_id — the ID of the project that owns the resource.
destination_project_id — UUID of the destination project that accepts the transfer resource 🎯
accepted — whether the transfer has been accepted or not (true/false vibes ✨)
expires_at — the date and time stamp of when the resource transfer expires. After the transfer expires, it gets automatically deleted 😭
links — pagination + bookmark links for the resource 🔗
accept(session, *, auth_key, clear_access_rules=False) — accepts a share transfer using the auth_key. Slay 🫶

The `ShareType` Class

Okay so ShareType inherits from Resource (that's <#openstack.resource.Resource> in the docs, iykyk).

class openstack.shared_file_system.v2.share_type.ShareType(_synchronized=False, connection=None, **attrs)

The base resource 💅

Parameters

_synchronized — not meant to be used directly, no cap. See new() (<#openstack.resource.Resource.new>) and existing() (<#openstack.resource.Resource.existing>).
connection — a reference to the Connection being used. Defaults to None so that Resource objects can be used without an active Connection, like in unit tests 🧪. Any use of self._connection inside Resource code should protect itself with a check for None.
resource_key = 'share_type' — the singular form of the key for the resource.
resources_key = 'share_types' — the plural form of the key for the resource.
base_path = '/types' — the base part of the URI for this resource 🌈
allow_create = True — allow the create operation for this resource.
allow_fetch = True — allow the get operation for this resource.
allow_commit = True — allow the update operation for this resource.
allow_delete = True — allow the delete operation for this resource.
allow_list = True — allow the list operation for this resource.
allow_head = False — allow the head operation for this resource (nope, not this one 🙈).
description — Properties: the description of the share type ✍️
extra_specs — list of extra specs for share types ✨
is_default — indicates if the share type is the default one 👑
is_public — indicates if the share type is public 🌍
required_extra_specs — list of required extra specs for share types 🔥
set_extra_specs(session, **specs) — updates extra_specs 💅

Heads up: this call replaces only the extra_specs with the same keys you give here. Other keys stay untouched, fr fr.

Parameters

session — the session to use for this request.
extra_specs — key/value extra_specs pairs to set or update.

Returns — the updated self 🫶

delete_extra_specs_property(session, prop) — deletes extra specs 🗑️

Parameters

session — the session to use for this request.
prop — the property to delete.

Returns — None.

`openstack.shared_file_system.v2.storage_pool`</p>

The `StoragePool` Class

StoragePool also inherits from Resource (<#openstack.resource.Resource>), periodt.

class openstack.shared_file_system.v2.storage_pool.StoragePool(_synchronized=False, connection=None, **attrs)

The base resource 🌸

Parameters

_synchronized — not meant for direct use, see new() (<#openstack.resource.Resource.new>) and existing() (<#openstack.resource.Resource.existing>).
connection — reference to the Connection being used. Defaults to None so Resource objects work without an active Connection (unit tests, bestie 🧪). Use of self._connection in Resource code should guard with a None check.
resources_key = 'pools' — the plural form of the key for the resource.
base_path = '/scheduler-stats/pools' — the base part of the URI for this resource 🌈
allow_create = False — allow the create operation for this resource (no 🙅)
allow_fetch = False — allow the get operation for this resource (also no)
allow_commit = False — allow the update operation for this resource (still no)
allow_delete = False — allow the delete operation for this resource (nope)
allow_list = True — allow the list operation for this resource (this one's a yes ✨)
allow_head = False — allow the head operation for this resource.
backend — Properties: the name of the back end 🧱
host — the host of the back end.
pool — the pool for the back end 🏊
capabilities — the back end capabilities 💪

`openstack.shared_file_system.v2.user_message`</p>

The `UserMessage` Class

Yep, UserMessage inherits from Resource too (<#openstack.resource.Resource>), it's giving family reunion 🫶

class openstack.shared_file_system.v2.user_message.UserMessage(_synchronized=False, connection=None, **attrs)

The base resource 💜

Parameters

_synchronized — not for direct use, see new() (<#openstack.resource.Resource.new>) and existing() (<#openstack.resource.Resource.existing>).
connection — reference to the Connection being used. Defaults to None so Resource objects can exist without an active Connection, like in unit tests. Any use of self._connection in Resource code should protect itself with a None check.
resource_key = 'message' — the singular form of the key for the resource.
resources_key = 'messages' — the plural form of the key for the resource.
base_path = '/messages' — the base part of the URI for this resource 📨
allow_fetch = True — allow the get operation for this resource.
allow_commit = False — allow the update operation for this resource (nope ✋).
allow_delete = True — allow the delete operation for this resource.
allow_list = True — allow the list operation for this resource.
allow_head = False — allow the head operation for this resource.
action_id — Properties: the action ID of the user message 🎬
created_at — indicates when the user message was created 🕐
detail_id — the detail ID of the user message.
expires_at — indicates when the share message expires ⌛
message_level — the message level of the user message.
project_id — the project ID of the user message.
request_id — the request ID of the user message.
resource_id — the resource ID of the user message.
resource_type — the resource type of the user message.
user_message — the message for the user message 💬

Workflow Resources 🦋

`openstack.workflow.v2.cron_trigger`</p>

The `CronTrigger` Class

CronTrigger inherits from Resource (<#openstack.resource.Resource>), obviously 💅

class openstack.workflow.v2.cron_trigger.CronTrigger(_synchronized=False, connection=None, **attrs)

The base resource ✨

Parameters

_synchronized — not intended to be used directly. See new() (<#openstack.resource.Resource.new>) and existing() (<#openstack.resource.Resource.existing>).
connection — reference to the Connection being used. Defaults to None to allow Resource objects to be used without an active Connection, such as in unit tests 🧪. Use of self._connection in Resource code should protect itself with a check for None.
resource_key = 'cron_trigger' — the singular form of the key for the resource.
resources_key = 'cron_triggers' — the plural form of the key for the resource.
base_path = '/cron_triggers' — the base part of the URI for this resource ⏰
allow_create = True — allow the create operation for this resource.
allow_list = True — allow the list operation for this resource.
allow_fetch = True — allow the get operation for this resource.
allow_delete = True — allow the delete operation for this resource.
create_opts — class-level configuration for the create operation. Subclasses can override this to set per-resource defaults without overriding create() 👑

CreateOpts(request_key=None, response_key=<Unset.UNSET: 'UNSET'>, method='POST', requires_id=<Unset.UNSET: 'UNSET'>, response_has_body=True)

name — the name of this Cron Trigger 🏷️
pattern — the pattern for this Cron Trigger.
remaining_executions — count of remaining exectuions (yes, that's how it's spelled in the docs, we don't gatekeep typos 😭)
first_execution_time — time of the first execution ⏱️
next_execution_time — time of the next execution ⏭️
workflow_name — workflow name.
workflow_id — workflow ID.
workflow_input — the inputs for the workflow 📥
workflow_params — workflow params.
project_id — the ID of the associated project.
created_at — the time at which the cron trigger was created 🕐
updated_at — the time at which the cron trigger was created (yep, the docs say "created" again — iconic copy-paste moment, we keep it exactly as-is 💀)

🧩 `openstack.workflow.v2.execution`

💫 The Execution Class

So the Execution class is a whole vibe and it inherits straight from Resource (iykyk, that's the base everything rides on). Here's the whole thing:

class openstack.workflow.v2.execution.Execution(_synchronized=False, connection=None, **attrs)

Yeah, she's the base resource. Let's talk params:

_synchronized — okay so this is not meant to be used directly, bestie. Like, do not touch. Go look at new() and existing() instead, they're the ones you actually want. 🙈
connection — a reference to the Connection being used. It defaults to None so you can build Resource objects with no active Connection at all, like in unit tests. And heads up: any code inside Resource that touches self._connection should guard itself with a check for None. Safety first, always. 🛡️

Now the class attributes — the icon lineup:

resource_key = 'execution' — the singular form of the key for this resource.
resources_key = 'executions' — the plural form of the key for this resource. Plural slay. ✨
base_path = '/executions' — the base part of the URI for this resource.
allow_create = True — allows the create operation for this resource.
allow_list = True — allows the list operation for this resource.
allow_fetch = True — allows the get operation for this resource.
allow_delete = True — allows the delete operation for this resource.
create_opts — class-level config for the create operation. Subclasses can override this to set per-resource defaults without overriding create(). Iconic behavior honestly:

create_opts = CreateOpts(request_key=None,
response_key=<Unset.UNSET: 'UNSET'>, method='POST',
requires_id=<Unset.UNSET: 'UNSET'>, response_has_body=True)

And the actual data fields on an Execution:

workflow_name — the name of the workflow.
workflow_id — the ID of the workflow.
description — a description of the workflow execution.
task_execution_id — a reference to the parent task execution.
status — can be one of: IDLE, RUNNING, SUCCESS, ERROR, or PAUSED. That's the whole mood ring, no cap. 🎢
status_info — an optional info string about the status. The little love note attached to the status. 💌
params — an optional JSON structure holding workflow type specific parameters.
output — the output of the workflow.
created_at — the time at which the Execution was created.
updated_at — the time at which the Execution was updated.

🧩 `openstack.workflow.v2.workflow`

🌸 The Workflow Class

And Workflow also inherits from Resource — same family, different flavor:

class openstack.workflow.v2.workflow.Workflow(_synchronized=False, connection=None, **attrs)

The base resource, again. Parameters, again:

_synchronized — not intended to be used directly, periodt. See new() and existing().
connection — reference to the Connection being used. Defaults to None so Resource objects work without an active Connection, like in unit tests. Anything touching self._connection in Resource code should protect itself with a None check.

The class attributes:

resource_key = 'workflow' — singular form of the key for this resource.
resources_key = 'workflows' — plural form of the key for this resource.
base_path = '/workflows' — the base part of the URI for this resource.
allow_create = True — allows the create operation for this resource.
allow_commit = True — allows the update operation for this resource. (Yes, it's called commit here, stay with me. 🫶)
allow_list = True — allows the list operation for this resource.
allow_fetch = True — allows the get operation for this resource.
allow_delete = True — allows the delete operation for this resource.

And the fields:

name — the name of this Workflow.
input — the inputs for this Workflow.
definition — a Workflow definition using the Mistral v2 DSL.
scope — can be either "private" or "public".
project_id — the ID of the associated project.
created_at — the time at which the workflow was created.
updated_at — the time at which the workflow was created.

Okay yes, updated_at says "created" in the docs. That's just what the docs say, I'm not out here inventing lore. Not me being the messenger 😭💀

🛠️ `create(session, prepend_key=True, base_path=None, **params)`

Creates a remote resource based on this instance. Like, makes it real. ✨

Parameters:

session — the session to use for making this request.
prepend_key — DEPRECATED, configure create_opts instead. Whether the resource_key should be prepended in a resource creation request. Defaults to True.
base_path — base part of the URI for creating resources, if it's different from base_path.
resource_request_key — DEPRECATED, configure create_opts instead. Overrides the usage of resource_key when prepending a key to the request body. Ignored if prepend_key is false.
resource_response_key — DEPRECATED, configure create_opts instead. Overrides the usage of resource_key when processing response bodies. Ignored if prepend_key is false.
microversion — API version to override the negotiated one.
params — additional params to pass.

Returns: this Resource instance. 💖

Raises: MethodNotSupported if Resource.allow_create is not set to True. So if you forgot to flip that flag, that's on you bestie.

🔄 `commit(session, prepend_key=True, has_body=True, retry_on_conflict=None, base_path=None, *, microversion=None, **kwargs)`

Commits the state of the instance to the remote resource. Push it live, queen. 👑

Parameters:

session — the session to use for making this request.
prepend_key — whether the resource_key should be prepended in a resource creation request. Defaults to True.
retry_on_conflict — whether to enable retries on HTTP CONFLICT (409). A value of None leaves the Adapter defaults alone.
base_path — base part of the URI for modifying resources, if it's different from base_path.
microversion — API version to override the negotiated one.
attrs — attributes to pass when updating the resource. These should correspond to either Body or Header values on the resource.

Returns: this Resource instance. 💖

Raises: MethodNotSupported if Resource.allow_commit is not set to True. Same energy as before — flip the flag or get the error.

🔮 Low-Level Classes

These next ones are not the ones app devs reach for every day, ngl — but they're what you use to build applications that talk to OpenStack APIs. Most of the time the Connection Interface handles all this for you, but if you wanna customize, the door's open. 🚪✨

🧱 Resource

The base resource class, the blueprint, the main character of the whole hierarchy.

Resource is a base class representing a remote resource. The attributes that make up a request or response for this resource are specified as class members on the Resource subclass, where their values are of a component type — that includes Body, Header, and URI. 🎀

For update management, Resource employs a series of _ComponentManager instances to look after the attributes of that particular component type. That's especially useful for the Body and Header types, so only the values that are actually necessary get sent in requests to the server. Efficiency ate. 💅

When making requests, each of the managers gets looked at to gather the necessary URI, body, and header data to build a request that goes out via keystoneauth's sessions. Responses coming back from keystoneauth then get converted into this Resource class' appropriate components and types, and handed right back to the caller. Round trip complete, no notes. 🌈

🧬 Components

class openstack.resource.Body(name, type=None, default=None, alias=None, aka=None, alternate_id=False, list_type=None, coerce_to_default=False, deprecated=False, deprecation_reason=None)

class openstack.resource.Header(name, type=None, default=None, alias=None, aka=None, alternate_id=False, list_type=None, coerce_to_default=False, deprecated=False, deprecation_reason=None)

class openstack.resource.URI(name, type=None, default=None, alias=None, aka=None, alternate_id=False, list_type=None, coerce_to_default=False, deprecated=False, deprecation_reason=None)

Three besties, same signature. Body, Header, URI. They come as a set. 🫶

👑 The Resource class

class openstack.resource.Resource(_synchronized=False, connection=None, **attrs)

The base resource. Params:

_synchronized — not intended to be used directly. See new() and existing(). (You've heard this before, and you'll hear it again. 💀)
connection — reference to the Connection being used. Defaults to None so Resource objects can be used without an active Connection, like in unit tests. Use of self._connection in Resource code should protect itself with a check for None.

Class attributes:

resource_key = None — singular form of the key for this resource.
resources_key = None — plural form of the key for this resource.
pagination_key = None — key used for pagination links.
id — the ID of this resource.
name — the name of this resource.
location — the OpenStack location of this resource.
base_path = '' — the base part of the URI for this resource. Empty string, humble but foundational. ⭐

Okay so here are the class-level switches and the actual action buttons on this resource — permission slips and methods, all the tea. 💅

allow_create = False — the permission slip for the create operation on this resource.
allow_fetch = False — the permission slip for the get operation on this resource.
allow_commit = False — the permission slip for the update operation on this resource.
allow_delete = False — the permission slip for the delete operation on this resource.
allow_list = False — the permission slip for the list operation on this resource.
allow_head = False — the permission slip for the head operation on this resource.
allow_patch = False — the permission slip for the patch operation on this resource.
requires_id = True — do calls for this resource require an ID? Yep, default is yes.
create_opts — class-level configuration for the create operation. Subclasses can override this to set per-resource defaults without overriding create().

create_opts = CreateOpts(request_key=<Unset.UNSET: 'UNSET'>, response_key=<Unset.UNSET: 'UNSET'>, method='POST', requires_id=<Unset.UNSET: 'UNSET'>, response_has_body=True)

allow_empty_commit = False — commits happen without header or body being dirty.
commit_method = 'PUT' — method for committing a resource. This must be PATCH if allow_patch is True.
microversion = None — API microversion (string or None) this Resource was loaded with.

keys() — return a set-like object providing a view on the dict's keys.
items() — return a set-like object providing a view on the dict's items.

classmethod new(**attrs)

Create a new instance of this resource. ✨

When creating the instance, set the _synchronized parameter of Resource to False to indicate that the resource does not yet exist on the server side. This marks all attributes passed in **attrs as "dirty" on the resource, and thusly tracked as necessary in subsequent calls such as update().

attrs — each of the named arguments will be set as attributes on the resulting Resource object. These should correspond to either Body or Header values on this resource.

classmethod existing(connection=None, **attrs)

Create an instance of an existing remote resource.

When creating the instance, set the _synchronized parameter of Resource to True to indicate that it represents the state of an existing server-side resource. As such, all attributes passed in **attrs are considered "clean", such that an immediate update() call would not generate a body of attributes to be modified on the server.

attrs — each of the named arguments will be set as attributes on the resulting Resource object.

Returns: an instance of self with the passed attributes set.

to_dict(body=True, headers=True, computed=True, ignore_none=False, original_names=False, _to_munch=False)

Return a dictionary of this resource's contents.

body — include the Body attributes in the returned dictionary.
headers — include the Header attributes in the returned dictionary.
computed — include the Computed attributes in the returned dictionary.
ignore_none — when True, exclude key/value pairs where the value is None. This will exclude attributes that the server hasn't returned.
original_names — when True, use attribute names as they were received from the server.
_to_munch — for internal use only. Converts to utils.Munch instead of dict.

Returns: a dictionary of key/value pairs where keys are named as they exist as attributes of this class.

toDict(body=True, headers=True, computed=True, ignore_none=False, original_names=False, _to_munch=False)

Return a dictionary of this resource's contents. Same exact vibe as to_dict(), bestie — every knob is still here:

body — include the Body attributes in the returned dictionary.
headers — include the Header attributes in the returned dictionary.
computed — include the Computed attributes in the returned dictionary.
ignore_none — when True, exclude key/value pairs where the value is None. This will exclude attributes that the server hasn't returned.
original_names — when True, use attribute names as they were received from the server.
_to_munch — for internal use only. Converts to utils.Munch instead of dict.

Returns: a dictionary of key/value pairs where keys are named as they exist as attributes of this class.

copy(body=True, headers=True, computed=True, ignore_none=False, original_names=False, _to_munch=False)

Return a dictionary of this resource's contents. Yes, it's the same contract again — here's every parameter so nothing gets lost:

body — include the Body attributes in the returned dictionary.
headers — include the Header attributes in the returned dictionary.
computed — include the Computed attributes in the returned dictionary.
ignore_none — when True, exclude key/value pairs where the value is None. This will exclude attributes that the server hasn't returned.
original_names — when True, use attribute names as they were received from the server.
_to_munch — for internal use only. Converts to utils.Munch instead of dict.

Returns: a dictionary of key/value pairs where keys are named as they exist as attributes of this class.

create(session, prepend_key=True, base_path=None, *, resource_request_key=None, resource_response_key=None, microversion=None, **params)

Create a remote resource based on this instance. 🎀

session — the session to use for making this request.
prepend_key — DEPRECATED — configure create_opts instead. Whether the resource_key should be prepended in a resource creation request. Defaults to True.
base_path — base part of the URI for creating resources, if different from base_path.
resource_request_key — DEPRECATED — configure create_opts instead. Overrides the usage of resource_key when prepending a key to the request body. Ignored if prepend_key is false.
resource_response_key — DEPRECATED — configure create_opts instead. Overrides the usage of resource_key when processing response bodies. Ignored if prepend_key is false.
microversion — API version to override the negotiated one.
params — additional params to pass.

Returns: this Resource instance.

Raises: MethodNotSupported (openstack.exceptions.MethodNotSupported) if Resource.allow_create is not set to True.

classmethod bulk_create(session, data, prepend_key=True, base_path=None, *, microversion=None, **params)

Create multiple remote resources based on this class and data. Group project energy. 🔥

session — the session to use for making this request.
data — list of dicts, which represent resources to create.
prepend_key — whether the resource_key should be prepended in a resource creation request. Defaults to True.
base_path — base part of the URI for creating resources, if different from base_path.
microversion — API version to override the negotiated one.
params — additional params to pass.

Returns: a generator of Resource objects.

Raises: MethodNotSupported (openstack.exceptions.MethodNotSupported) if Resource.allow_create is not set to True.

fetch(session, requires_id=True, base_path=None, error_message=None, skip_cache=False, *, resource_response_key=None, microversion=None, **params)

Get a remote resource based on this instance.

session — the session to use for making this request.
requires_id — whether resource ID should be part of the requested URI.
base_path — base part of the URI for fetching resources, if different from base_path.
error_message — an error message to be returned if requested object does not exist.
skip_cache — a boolean indicating whether optional API cache should be skipped for this invocation.
resource_response_key — overrides how self.resource_key gets used when the response body is processed. 💅
microversion — API version to override the negotiated one. ✨
params — extra parameters that can be consumed. 🍓

Returns — this Resource instance. 💖

Raises MethodNotSupported (openstack.exceptions.MethodNotSupported) if Resource.allow_fetch is not set to True. 😤

Raises NotFoundException (openstack.exceptions.NotFoundException) if the resource was not found. 😭

head

head(session, base_path=None, *, microversion=None)

Grabs the headers from a remote resource based on this instance. Like, you're not fetching the whole body, just the metadata — very main character energy. 🎀

Parameters

session — the session to use for making this request. 🫶
base_path — base part of the URI for fetching resources, if it's different from base_path. (Yes, same name, different job. iconic.) 💅
microversion — API version to override the negotiated one. ✨

Returns — this Resource instance. 💖

Raises MethodNotSupported (openstack.exceptions.MethodNotSupported) if Resource.allow_head is not set to True. 🚫

Raises NotFoundException (openstack.exceptions.NotFoundException) if the resource was not found. 😭

property `requires_commit`

Tells you whether the next commit() call will actually do anything. Lowkey a vibe check for your pending changes. 👀

commit

commit(session, prepend_key=True, has_body=True,
       retry_on_conflict=None, base_path=None, *, microversion=None,
       **attrs)

Commits the state of the instance to the remote resource. It's giving "make it official" energy. 💍

Parameters

session — the session to use for making this request. 🫶
prepend_key — whether the resource_key should be prepended in a resource creation request. Defaults to True. 🎀
retry_on_conflict — whether to enable retries on HTTP CONFLICT (409). A value of None leaves the Adapter defaults. 🔁
base_path — base part of the URI for modifying resources, if it's different from base_path. 💅
microversion — API version to override the negotiated one. ✨
attrs — attributes to pass when updating the resource. These should correspond to either Body or Header values on the resource. 🧚

Returns — this Resource instance. 💖

Raises MethodNotSupported (openstack.exceptions.MethodNotSupported) if Resource.allow_commit is not set to True. 😤

patch

patch(session, patch=None, prepend_key=True, has_body=True,
      retry_on_conflict=None, base_path=None, *, microversion=None)

Patches the remote resource. 🩹

Lets you modify the resource by providing a list of JSON patches to apply to it. The patches can use both the original (server-side) and SDK field names — so you can speak either language, no cap. 🔥

Parameters

session — the session to use for making this request. 🫶
patch — additional JSON patch as a list or one patch item. If provided, it's applied on top of any changes to the current resource. 🎀
prepend_key — whether the resource_key should be prepended in a resource creation request. Defaults to True. 💅
retry_on_conflict — whether to enable retries on HTTP CONFLICT (409). A value of None leaves the Adapter defaults. 🔁
base_path — base part of the URI for modifying resources, if it's different from base_path. ✨
microversion — API version to override the negotiated one. ⭐

Returns — this Resource instance. 💖

Raises MethodNotSupported (openstack.exceptions.MethodNotSupported) if Resource.allow_patch is not set to True. 😤

delete

delete(session, error_message=None, *, microversion=None,
       base_path=None, params=None)

Deletes the remote resource based on this instance. Bye bestie! 👋💀

Parameters

session — the session to use for making this request. 🫶
microversion — API version to override the negotiated one. ✨
base_path — base part of the URI for modifying resources, if it's different from base_path. 💅
params — query string parameters to include in the request URL. 🍓

Returns — this Resource instance. 💖

Raises MethodNotSupported (openstack.exceptions.MethodNotSupported) if Resource.allow_commit is not set to True. (Yes, it says allow_commit here — we're just the messenger. 🙈)

Raises NotFoundException (openstack.exceptions.NotFoundException) if the resource was not found. 😭

classmethod `list`

classmethod list(session, paginated=True, base_path=None,
                 allow_unknown_params=False, *, microversion=None, headers=None,
                 max_items=None, **params)

This method is a generator that yields resource objects. It handles pagination and takes query params for response filtering. It's giving "infinite scroll but make it API". 🌈

Parameters

session — the session to use for making this request. 🫶
paginated — True if a GET to this resource returns a paginated series of responses, or False if a GET returns only one page of data. When paginated is False, only one page of data will be returned regardless of the API's support for pagination. 📄
base_path — base part of the URI for listing resources, if it's different from base_path. 💅
allow_unknown_params — True to accept but discard unknown query parameters. This lets you get a list of 'filters' and pass everything known to the server. False will result in a validation exception when unknown query parameters are passed. 🚫
microversion — API version to override the negotiated one. ✨
headers — additional headers to inject into the HTTP request. 🎀
max_items — the maximum number of items to return. Typically this must be used with paginated=True. 🔢
params — these keyword arguments are passed through the _transpose() method to find if any of them match expected query parameters to be sent in the params argument to get(). They're additionally checked against the base_path format string to see if any path fragments need to be filled in by the contents of this argument. Parameters supported as filters by the server side are passed in the API call; remaining parameters are applied as filters to the retrieved results. 🧚

Returns — a generator of Resource objects. 💖

Raises MethodNotSupported (openstack.exceptions.MethodNotSupported) if Resource.allow_list is not set to True. 😤

Raises InvalidResourceQuery (openstack.exceptions.InvalidResourceQuery) if the query contains invalid params. 💀

classmethod `find`

classmethod find(session, name_or_id, ignore_missing=True,
                 list_base_path=None, *, microversion=None, all_projects=None,
                 **params)

Finds a resource by its name or id. It's giving detective energy. 🔍

Parameters

session — the session to use for making this request. 🫶
name_or_id — this resource's identifier, if needed by the request. The default is None. 🎀
ignore_missing — when set to False, NotFoundException (openstack.exceptions.NotFoundException) will be raised when the resource does not exist. When set to True, None will be returned when attempting to find a nonexistent resource. 🙈
list_base_path — base_path to be used when you need to list resources. 💅
microversion — API version to override the negotiated one. ✨
params — any additional parameters to be passed into underlying methods, such as to existing() in order to pass on URI parameters. 🍓

Returns — the Resource object matching the given name or id, or None if nothing matches. 💖

Raises openstack.exceptions.DuplicateResource if more than one resource is found for this request. 😭

Raises openstack.exceptions.NotFoundException if nothing is found and ignore_missing is False. 💀

💅 ServiceDescription 💅

okay bestie, meet the class that tells the SDK how to vibe with a REST service:

class openstack.service_description.ServiceDescription(service_type, supported_versions=None, aliases=None)

This is literally the class that describes how to interact with a REST service. No cap.

Every service in an OpenStack cloud has to be found by looking for it in the catalog. Once the endpoint is found, you can make REST calls — but you need a Proxy class and some Resource objects to get that object interface, fr fr.

Instances of ServiceDescription can be passed to openstack.connection.Connection.add_service, or a list can be passed to the openstack.connection.Connection constructor in the extra_services argument. iykyk

All three parameters can be provided at instantation time, or a service-specific subclass can be used that sets the attributes directly.

Parameters

service_type — service_type to look for in the keystone catalog
aliases — Optional list of aliases, if there is more than one name that might be used to register the service in the catalog.
service_type — main service_type to use to find this service in the catalog
supported_versions = {} — Dictionary of supported versions and proxy classes for that version
aliases = [] — list of aliases this service might be registered as

🧚 ServiceDescription object 🧚

same class, same icon energy — the object version is right above, bestie. The attributes are service_type, supported_versions = {}, and aliases = [], exactly as listed.

🛠️ Utilities 🛠️

🌸 Errors and warnings 🌸

The SDK attempts to provide detailed errors and warnings for things like failed requests, deprecated APIs, and invalid configurations. Application developers are responsible for handling these errors and can opt into warnings to ensure their applications stay up-to-date. you got this, but also handle your exceptions pls

🌈 Exceptions 🌈

openstacksdk provides a number of exceptions (the Python kind: https://docs.python.org/3/library/exceptions.html) for commonly encountered issues, such as missing API endpoints, various HTTP error codes, timeouts and so forth. It is the responsibility of the calling application to handle these exceptions appropriately.

⭐ Available exceptions ⭐

Exception definitions, bestie:

exception openstack.exceptions.SDKException(message=None, extra_data=None) — The base exception class for all exceptions this library raises.
exception openstack.exceptions.EndpointNotFound(message=None) — A mismatch occurred between what the client and server expect.
exception openstack.exceptions.InvalidResponse(message=None) — The response from the server is not valid for this request.
exception openstack.exceptions.InvalidRequest(message=None) — The request to the server is not valid.
exception openstack.exceptions.HttpException(message='Error', response=None, http_status=None, details=None, request_id=None) — The base exception for all HTTP error responses. Initialize RequestException with request and response objects.
exception openstack.exceptions.BadRequestException(message='Error', response=None, http_status=None, details=None, request_id=None) — HTTP 400 Bad Request. Initialize RequestException with request and response objects.
exception openstack.exceptions.NotFoundException(message='Error', response=None, http_status=None, details=None, request_id=None) — HTTP 404 Not Found. Initialize RequestException with request and response objects.
exception openstack.exceptions.ForbiddenException(message='Error', response=None, http_status=None, details=None, request_id=None) — HTTP 403 Forbidden Request. Initialize RequestException with request and response objects.
exception openstack.exceptions.ConflictException(message='Error', response=None, http_status=None, details=None, request_id=None) — HTTP 409 Conflict. Initialize RequestException with request and response objects.
exception openstack.exceptions.PreconditionFailedException(message='Error', response=None, http_status=None, details=None, request_id=None) — HTTP 412 Precondition Failed. Initialize RequestException with request and response objects.
exception openstack.exceptions.MethodNotSupported(resource, method) — The resource does not support this operation type.
exception openstack.exceptions.DuplicateResource(message=None, extra_data=None) — More than one resource exists with that name.
exception openstack.exceptions.ResourceTimeout(message=None, extra_data=None) — Timeout waiting for resource.
exception openstack.exceptions.ResourceFailure(message=None, extra_data=None) — General resource failure.
exception openstack.exceptions.InvalidResourceQuery(message=None, extra_data=None) — Invalid query params for resource.
openstack.exceptions.raise_from_response(response, error_message=None) — Raise an instance of an HTTPException based on keystoneauth response.
exception openstack.exceptions.ConfigException(message=None, extra_data=None) — Something went wrong with parsing your OpenStack Config.
exception openstack.exceptions.NotSupported(message=None, extra_data=None) — Request cannot be performed by any supported API version.
exception openstack.exceptions.ValidationException(message=None, extra_data=None) — Validation failed for resource.
exception openstack.exceptions.ServiceDisabledException(message=None, extra_data=None) — This service is disabled for reasons.
exception openstack.exceptions.ServiceDiscoveryException(message=None, extra_data=None) — The service cannot be discovered.
openstack.exceptions.OpenStackCloudException — alias of SDKException
openstack.exceptions.ResourceNotFound — alias of NotFoundException

🎀 Warnings 🎀

openstacksdk uses the warnings infrastructure (https://docs.python.org/3/library/warnings.html) to warn users about deprecated resources and resource fields, as well as deprecated behavior in openstacksdk itself. These warnings are derived from Warning or DeprecationWarning. In Python, warnings are emitted by default while deprecation warnings are silenced by default and must be turned on using the -Wa Python command line option or the PYTHONWARNINGS environment variable. If you are writing an application that uses openstacksdk, you may wish to enable some of these warnings during test runs to ensure you migrate away from deprecated behavior. future-you will thank present-you, bestie

🦋 Available warnings 🦋

exception openstack.warnings.OpenStackDeprecationWarning — Base class for warnings about deprecated features in openstacksdk.
exception openstack.warnings.RemovedResourceWarning — Indicates that a resource has been removed in newer API versions and should not be used.
exception openstack.warnings.RemovedFieldWarning — Indicates that a field has been removed in newer API versions and should not be used.
exception openstack.warnings.LegacyAPIWarning — Indicates an API that is in 'legacy' status, a long term deprecation.
exception openstack.warnings.RemovedInSDK50Warning — Indicates an argument that is deprecated for removal in SDK 5.0.
exception openstack.warnings.RemovedInSDK60Warning — Indicates an argument that is deprecated for removal in SDK 6.0.
exception openstack.warnings.OpenStackWarning — Base class for general warnings in openstacksdk.
exception openstack.warnings.ConfigurationWarning — Indicates an issue with configuration.
exception openstack.warnings.UnsupportedServiceVersion — Indicates a major version that SDK doesn't understand.

👑 Presentations 👑

🍓 Multi-Cloud Demo 🍓

This document contains a presentation in presentty (https://pypi.org/project/presentty) format. If you want to walk through it like a presentation, install presentty and run:

presentty doc/source/user/multi-cloud-demo.rst

The content is hopefully helpful even if it's not being narrated, so it's being included in the openstacksdk docs. lowkey iconic of them

💜 Who am I? 💜

Monty Taylor

OpenStack Infra Core
irc: mordred
twitter: @e_monty

🔥 What are we going to talk about? 🔥

OpenStackSDK

a task and end-user oriented Python library
abstracts deployment differences
designed for multi-cloud
simple to use
massive scale
- optional advanced features to handle 20k servers a day
Initial logic/design extracted from nodepool
Librified to re-use in Ansible

🌸 OpenStackSDK is Free Software 🌸

https://opendev.org/openstack/openstacksdk
openstack-discuss@lists.openstack.org
#openstack-sdks on oftc

✨ This talk is Free Software, too ✨

Written for presentty (https://pypi.org/project/presentty)
doc/source/user/multi-cloud-demo.rst
examples in examples/cloud
Paths subject to change - this is the first presentation in tree!

💅 Complete Example 💅

from openstack import cloud as openstack

# Initialize and turn on debug logging
openstack.enable_logging(debug=True)

for cloud_name, region_name in [
    ('my-vexxhost', 'ca-ymq-1'),
    ('my-citycloud', 'Buf1'),
    ('my-internap', 'ams01'),
]:
    # Initialize cloud
    cloud = openstack.connect(cloud=cloud_name, region_name=region_name)

    # Upload an image to the cloud
    image = cloud.create_image(
        'devuan-jessie',
        filename='devuan-jessie.qcow2',
        wait=True,
    )

    # Find a flavor with at least 512M of RAM
    flavor = cloud.get_flavor_by_ram(512)

    # Boot a server, wait for it to boot, and then do whatever is needed
    # to get a public ip for it.
    cloud.create_server(
        'my-server',
        image=image,
        flavor=flavor,
        wait=True,
        auto_ip=True,
    )

🧚 Let's Take a Few Steps Back 🧚

Multi-cloud is easy, but you need to know a few things.

Terminology
Config
OpenStackSDK API

🌈 Cloud Terminology 🌈

Let's define a few terms, so that we can use them with ease:

cloud - logically related collection of services
region - completely independent subset of a given cloud
patron - human who has an account
user - account on a cloud
project - logical collection of cloud resources
domain - collection of users and projects

⭐ Cloud Terminology Relationships ⭐

A cloud has one or more regions
A patron has one or more users
A patron has one or more projects
A cloud has one or more domains
In a cloud with one domain it is named "default"
Each patron may have their own domain
Each user is in one domain
Every project lives inside exactly one domain 🏠
A user holds one or more roles on one or more projects — that's the whole permission vibe ✨

🌐 HTTP Sessions 🌐

Every HTTP interaction gets authenticated through keystone 🔑
Authenticating hands you back a token
An authenticated HTTP Session is shared across a region — one session, whole region, slay

☁️ Cloud Regions ☁️

A cloud region is the basic unit of REST interaction. Like, the atom of the whole thing 💅

A cloud has a service catalog
The service catalog comes back inside the token
The service catalog lists the endpoint for each service in each region
A region is completely autonomous — it answers to nobody 👑

👥 Users, Projects and Domains 👥

Okay so in clouds with multiple domains, project and user names are only unique within a region. Yeah. Read that again 😭

Names need domain info for uniqueness. IDs do not.
Handing over domain info when it's not needed is totally fine, no harm
project_name requires project_domain_name or project_domain_id
project_id does not
username requires user_domain_name or user_domain_id
user_id does not

😵 Confused Yet? 😵

Don't worry bestie — you genuinely don't have to deal with most of that. Deep breath, we're fine 🫶

🎯 Auth per cloud, select per region 🎯

In general, the thing you actually need to know is:

Configure authentication per cloud
Select config to use by cloud and region

📄 clouds.yaml 📄

Information about the clouds you want to connect to lives in a file called clouds.yaml 💖

clouds.yaml can be in your homedir: ~/.config/openstack/clouds.yaml or system-wide: /etc/openstack/clouds.yaml.

Information in your homedir, if it exists, takes precedence. Homedir wins, always, no cap.

Full docs on clouds.yaml are at https://docs.openstack.org/os-client-config/latest/ 📚

🍎 What about Mac and Windows? 🪟

USER_CONFIG_DIR is different on Linux, OSX and Windows. It's giving ✨diversity✨

Linux: ~/.config/openstack
OSX: ~/Library/Application Support/openstack
Windows: C:\Users\USERNAME\AppData\Local\OpenStack\openstack

SITE_CONFIG_DIR is different on Linux, OSX and Windows too:

Linux: /etc/openstack
OSX: /Library/Application Support/openstack
Windows: C:\ProgramData\OpenStack\openstack

🧠 Config Terminology 🧠

For multi-cloud situations, think of two types:

profile — facts about the cloud that are true for everyone
cloud — information specific to a given user

Apologies for the use of cloud twice. The naming committee was on break that day 🙈

🌱 Environment Variables and Simple Usage 🌱

Environment variables starting with OS_ go into a cloud called envvars
If you only have one cloud, you don't have to specify it 🎉
OS_CLOUD and OS_REGION_NAME are default values for cloud and region_name

🎤 TOO MUCH TALKING - NOT ENOUGH CODE 🎤

💾 basic clouds.yaml for the example code 💾

Simple example of a clouds.yaml, just to get your feet wet:

Config for a named cloud my-citycloud
Reference a well-known "named" profile: citycloud
os-client-config has a built-in list of profiles at https://docs.openstack.org/openstacksdk/latest/user/config/vendor-support.html
Vendor profiles contain various advanced config
Cloud name can match profile name (we're using different names here for clarity 👀)

clouds:
  my-citycloud:
    profile: citycloud
    auth:
      username: mordred
      project_id: 65222a4d09ea4c68934fa1028c77f394
      user_domain_id: d0919bd5e8d74e49adf0e145807ffc38
      project_domain_id: d0919bd5e8d74e49adf0e145807ffc38

Where's the password? 🤨 (spoiler: next section)

🔐 secure.yaml 🔐

Optional extra file, works exactly like clouds.yaml
Values get overlaid onto clouds.yaml
Useful if you want to protect secrets more stringently — very valid, very demure

🙈 Example secure.yaml 🙈

No, my password isn't literally XXXXXXXX 😭
Cloud name should match the one in clouds.yaml
Optional — bestie, I actually keep mine in my clouds.yaml 💀

clouds:
  my-citycloud:
    auth:
      password: XXXXXXXX

➕ more clouds.yaml ➕

More information can be provided. It's not just the basics 👑

Use v3 of the identity API — even if others are present
Use https://image-ca-ymq-1.vexxhost.net/v2 for the image API instead of whatever's in the catalog

  my-vexxhost:
    identity_api_version: 3
    image_endpoint_override: https://image-ca-ymq-1.vexxhost.net/v2
    profile: vexxhost
    auth:
      user_domain_id: default
      project_domain_id: default
      project_name: d8af8a8f-a573-48e6-898a-af333b970a2d
      username: 0b8c435b-cc4d-4e05-8a47-a2ada0539af1

🌈 Much more complex clouds.yaml example 🌈

Not using a profile — all settings included, doing it manually 💅
In the ams01 region there are two networks with undiscoverable qualities
Each one is labeled here so choices can be made
Any of the settings can be region-specific if needed
Region settings override cloud settings
This cloud does not support floating-ips

my-internap:
  auth:
    auth_url: https://identity.api.cloud.inap.com
    username: api-55f9a00fb2619
    project_name: inap-17037
  identity_api_version: 3
  floating_ip_source: None
  regions:
  - name: ams01
    values:
      networks:
      - name: inap-17037-WAN1654
        routes_externally: true
        default_interface: true
      - name: inap-17037-LAN3631
        routes_externally: false

🔁 Complete Example Again 🔁

from openstack import cloud as openstack

# Initialize and turn on debug logging
openstack.enable_logging(debug=True)

for cloud_name, region_name in [
        ('my-vexxhost', 'ca-ymq-1'),
        ('my-citycloud', 'Buf1'),
        ('my-internap', 'ams01')]:
    # Initialize cloud
    cloud = openstack.connect(cloud=cloud_name, region_name=region_name)

    # Upload an image to the cloud
    image = cloud.create_image(
        'devuan-jessie', filename='devuan-jessie.qcow2', wait=True)

    # Find a flavor with at least 512M of RAM
    flavor = cloud.get_flavor_by_ram(512)

    # Boot a server, wait for it to boot, and then do whatever is needed
    # to get a public ip for it.
    cloud.create_server(
        'my-server', image=image, flavor=flavor, wait=True, auto_ip=True)

🪜 Step By Step 🪜

📦 Import the library 📦

from openstack import cloud as openstack

🪵 Logging 🪵

openstacksdk uses standard python logging
openstack.enable_logging does the easy defaults for you
It squelches some meaningless warnings — thank you honestly 🙏
- debug
  - Logs openstacksdk loggers at debug level
- http_debug implies debug, and turns on HTTP tracing

# Initialize and turn on debug logging
openstack.enable_logging(debug=True)

🐛 Example with Debug Logging 🐛

examples/cloud/debug-logging.py

from openstack import cloud as openstack
openstack.enable_logging(debug=True)

cloud = openstack.connect(cloud='my-vexxhost', region_name='ca-ymq-1')
cloud.get_image('Ubuntu 16.04.1 LTS [2017-03-03]')

🕵️ Example with HTTP Debug Logging 🕵️

examples/cloud/http-debug-logging.py

from openstack import cloud as openstack
openstack.enable_logging(http_debug=True)

cloud = openstack.connect(
    cloud='my-vexxhost', region_name='ca-ymq-1')
cloud.get_image('Ubuntu 16.04.1 LTS [2017-03-03]')

🗺️ Cloud Regions 🗺️

The cloud constructor needs cloud and region_name
openstack.connect is a helper factory function ✨

for cloud_name, region_name in [
    ('my-vexxhost', 'ca-ymq-1'),
    ('my-citycloud', 'Buf1'),
    ('my-internap', 'ams01')
]:
    # Initialize cloud
    cloud = openstack.connect(cloud=cloud_name, region_name=region_name)

📤 Upload an Image 📤

Picks the correct upload mechanism for you, no thinking required
SUGGESTION Always upload your own base images 👀

# Upload an image to the cloud
image = cloud.create_image(
    'devuan-jessie',
    filename='devuan-jessie.qcow2',
    wait=True,
)

💾 Always Upload an Image 💾

Ok. You don't have to. But, for multi-cloud...

Images with the same content are named differently on different clouds
Images with the same name on different clouds can have different content
Upload your own to all clouds and both problems just vanish ✨
Download from the OS vendor, or build with diskimage-builder

🍦 Find a flavor 🍦

Flavors are all named differently on clouds (of course they are 😭)
Flavors can be found via RAM
get_flavor_by_ram finds the smallest matching flavor

# Find a flavor with at least 512M of RAM
flavor = cloud.get_flavor_by_ram(512)

🚀 Create a server 🚀

my-vexxhost
- Boot server
- Wait for status==ACTIVE
my-internap
- Boot server on network inap-17037-WAN1654
- Wait for status==ACTIVE
my-citycloud
- Boot server
- Wait for status==ACTIVE
- Find the port for the fixed_ip for the server
- Create a floating-ip on that port
- Wait for the floating-ip to attach

# Boot a server, wait for it to boot, and then do whatever is needed
# to get a public ip for it.
cloud.create_server(
    'my-server', image=image, flavor=flavor, wait=True, auto_ip=True)

Wow. We didn't even deploy Wordpress! 😭💀

🏷️ Image and Flavor by Name or ID 🏷️

Pass a string to image/flavor
The Image/Flavor will be found by name or ID
Common pattern
examples/cloud/create-server-name-or-id.py

from openstack import cloud as openstack

# Initialize and turn on debug logging
openstack.enable_logging(debug=True)

for cloud_name, region_name, image, flavor in [
        ('my-vexxhost', 'ca-ymq-1',
         'Ubuntu 16.04.1 LTS [2017-03-03]', 'v1-standard-4'),
        ('my-citycloud', 'Buf1',
         'Ubuntu 16.04 Xenial Xerus', '4C-4GB-100GB'),
        ('my-internap', 'ams01',
         'Ubuntu 16.04 LTS (Xenial Xerus)', 'A1.4')]:
    # Initialize cloud
    cloud = openstack.connect(cloud=cloud_name, region_name=region_name)

    # Boot a server, wait for it to boot, and then do whatever is needed
    # to get a public ip for it.
    server = cloud.create_server(
        'my-server', image=image, flavor=flavor, wait=True, auto_ip=True)
    print(server.name)
    print(server['name'])
    cloud.pprint(server)
    # Delete it - this is a demo
    cloud.delete_server(server, wait=True, delete_ips=True)

🧹 Delete Servers 🧹

delete_ips — delete any floating_ips the server may have

cloud.delete_server('my-server', wait=True, delete_ips=True)

📚 Image and Flavor by Dict 📚

Pass a dict to image/flavor
If you know whether the value is a Name or an ID 👀
Common pattern
examples/cloud/create-server-dict.py

from openstack import cloud as openstack

# Initialize and turn on debug logging
openstack.enable_logging(debug=True)

for cloud_name, region_name, image, flavor_id in [
        ('my-vexxhost', 'ca-ymq-1', 'Ubuntu 16.04.1 LTS [2017-03-03]',
         '5cf64088-893b-46b5-9bb1-ee020277635d'),
        ('my-citycloud', 'Buf1', 'Ubuntu 16.04 Xenial Xerus',
         '0dab10b5-42a2-438e-be7b-505741a7ffcc'),
        ('my-internap', 'ams01', 'Ubuntu 16.04 LTS (Xenial Xerus)',
         'A1.4')]:
    # Initialize cloud
    cloud = openstack.connect(cloud=cloud_name, region_name=region_name)

    # Boot a server, wait for it to boot, and then do whatever is needed
    # to get a public ip for it.
    server = cloud.create_server(
        'my-server', image=image, flavor=dict(id=flavor_id),
        wait=True, auto_ip=True)
    # Delete it - this is a demo
    cloud.delete_server(server, wait=True, delete_ips=True)

🌸 Munch Objects 🌸

ok so this is one of my favorite little things, bestie 💖

They behave like a dict and like an object — both at once, no cap
peep the example at examples/cloud/munch-dict-object.py

from openstack import cloud as openstack
openstack.enable_logging(debug=True)

cloud = openstack.connect(cloud='zetta', region_name='no-osl1')
image = cloud.get_image('Ubuntu 14.04 (AMD64) [Local Storage]')
print(image.name)
print(image['name'])

like?? image.name and image['name'] are the same thing?? iconic behaviour honestly ✨

🦋 API Organized by Logical Resource 🦋

the naming here is so clean, it's giving main character energy:

list_servers
search_servers
get_server
create_server
delete_server
update_server

and for everything else, it's still {verb}_{noun} — the pattern never misses 💅

attach_volume
wait_for_server
add_auto_ip

🎀 Cleanup Script 🎀

ngl, sometimes my examples had bugs 😭 so here's the cleanup situation:

it lives at examples/cloud/cleanup-servers.py

from openstack import cloud as openstack

# Initialize and turn on debug logging
openstack.enable_logging(debug=True)

for cloud_name, region_name in [
        ('my-vexxhost', 'ca-ymq-1'),
        ('my-citycloud', 'Buf1'),
        ('my-internap', 'ams01')]:
    # Initialize cloud
    cloud = openstack.connect(cloud=cloud_name, region_name=region_name)
    for server in cloud.search_servers('my-server'):
        cloud.delete_server(server, wait=True, delete_ips=True)

👑 Normalization 👑

examples/cloud/normalization.py

from openstack import cloud as openstack
openstack.enable_logging()

cloud = openstack.connect(cloud='fuga', region_name='cystack')
image = cloud.get_image(
    'Ubuntu 16.04 LTS - Xenial Xerus - 64-bit - Fuga Cloud Based Image')
cloud.pprint(image)

⭐ Strict Normalized Results ⭐

it returns only the declared model — nothing extra, no crumbs, periodt
examples/cloud/strict-mode.py

from openstack import cloud as openstack
openstack.enable_logging()

cloud = openstack.connect(
    cloud='fuga', region_name='cystack', strict=True)
image = cloud.get_image(
    'Ubuntu 16.04 LTS - Xenial Xerus - 64-bit - Fuga Cloud Based Image')
cloud.pprint(image)

🧚 How Did I Find the Image Name for the Last Example? 🧚

honestly? I often make stupid little utility scripts 💀 and they ate
examples/cloud/find-an-image.py

from openstack import cloud as openstack
openstack.enable_logging()

cloud = openstack.connect(cloud='fuga', region_name='cystack')
cloud.pprint([
    image for image in cloud.list_images()
    if 'ubuntu' in image.name.lower()])

🔥 Added / Modified Information 🔥

Servers need more extra help — they're high maintenance like that
Fetch addresses dict from neutron
Figure out which IPs are good
detailed — defaults to True, add everything
bare — no extra calls — don't even fix broken things
bare is still normalized
examples/cloud/server-information.py

from openstack import cloud as openstack
openstack.enable_logging(debug=True)

cloud = openstack.connect(cloud='my-citycloud', region_name='Buf1')
try:
    server = cloud.create_server(
        'my-server', image='Ubuntu 16.04 Xenial Xerus',
        flavor=dict(id='0dab10b5-42a2-438e-be7b-505741a7ffcc'),
        wait=True, auto_ip=True)

    print("\n\nFull Server\n\n")
    cloud.pprint(server)

    print("\n\nTurn Detailed Off\n\n")
    cloud.pprint(cloud.get_server('my-server', detailed=False))

    print("\n\nBare Server\n\n")
    cloud.pprint(cloud.get_server('my-server', bare=True))

finally:
    # Delete it - this is a demo
    cloud.delete_server(server, wait=True, delete_ips=True)

💜 Exceptions 💜

ok pay attention bestie, this part is important:

All openstacksdk exceptions are subclasses of OpenStackCloudException
Direct REST calls throw OpenStackCloudHTTPError
OpenStackCloudHTTPError subclasses OpenStackCloudException and requests.exceptions.HTTPError
OpenStackCloudURINotFound for 404
OpenStackCloudBadRequest for 400

🌈 User Agent Info 🌈

Set app_name and app_version for User Agents
(ssh ... region_name is optional if the cloud has one region)
examples/cloud/user-agent.py

from openstack import cloud as openstack
openstack.enable_logging(http_debug=True)

cloud = openstack.connect(
    cloud='datacentred',
    app_name='AmazingApp',
    app_version='1.0',
)
cloud.list_networks()

🍓 Uploading Large Objects 🍓

swift has a maximum object size — rude, but okay
Large Objects are uploaded specially
openstacksdk figures this out and does it for you 🫶
multi-threaded, we love efficiency
examples/cloud/upload-object.py

from openstack import cloud as openstack
openstack.enable_logging(debug=True)

cloud = openstack.connect(cloud='ovh', region_name='SBG1')
cloud.create_object(
    container='my-container',
    name='my-object',
    filename='/home/mordred/briarcliff.sh3d',
)
cloud.delete_object('my-container', 'my-object')
cloud.delete_container('my-container')

🎀 Uploading Large Objects 🎀

(yes, same title again — it's a sequel, and sequels slay)

Default max_file_size is 5G
This is a conference demo, be normal about it
Let's force a segment_size
One MILLION bytes 💀
examples/cloud/upload-object.py

from openstack import cloud as openstack
openstack.enable_logging(debug=True)

cloud = openstack.connect(cloud='ovh', region_name='SBG1')
cloud.create_object(
    container='my-container',
    name='my-object',
    filename='/home/mordred/briarcliff.sh3d',
    segment_size=1000000,
)
cloud.delete_object('my-container', 'my-object')
cloud.delete_container('my-container')

💅 Service Conditionals 💅

from openstack import cloud as openstack
openstack.enable_logging(debug=True)

cloud = openstack.connect(cloud='kiss', region_name='region1')
print(cloud.has_service('network'))
print(cloud.has_service('container-orchestration'))

🌸 Service Conditional Overrides 🌸

Sometimes clouds are weird and figuring that out won't work — respectfully, some clouds just have main character energy of their own 😭

from openstack import cloud as openstack
openstack.enable_logging(debug=True)

cloud = openstack.connect(cloud='rax', region_name='DFW')
print(cloud.has_service('network'))

clouds:
  rax:
    profile: rackspace
    auth:
      username: mordred
      project_id: 245018
    # This is already in profile: rackspace
    has_network: false

✨ FIN ✨

💖 FOR CONTRIBUTORS 💖

🫶 Contributing to the OpenStack SDK 🫶

okay so this whole section is for the girlies who wanna contribute to the development of this SDK 💅 This section of documentation pertains to those who wish to contribute to the development of this SDK. If you're looking for documentation on how to use the SDK to build applications, refer to the ../user section instead — that's the vibe you want, bestie.

🦋 About the Project 🦋

The OpenStack SDK is a OpenStack project aimed at providing a complete software development kit for the programs which make up the OpenStack community. It is a Python library with corresponding documentation, examples, and tools released under the Apache 2 license. iconic, honestly 👑

🎀 A Brief History 🎀

okay storytime, because this is genuinely so interesting — openstacksdk started its life as three different libraries: shade, os-client-config and python-openstacksdk. three separate girlies who eventually realized they were the same girlie 😭

shade — shade started its life as some code inside of OpenStack Infra's nodepool project (https://docs.openstack.org/infra/nodepool/), and as some code inside of the Ansible OpenStack Modules (http://docs.ansible.com/ansible/latest/list_of_cloud_modules.html#openstack). Ansible had a bunch of different OpenStack related modules, and there was a ton of duplicated code. Eventually, between refactoring that duplication into an internal library, and adding the logic and features that the OpenStack Infra team had developed to run client applications at scale, it turned out that we'd written nine-tenths of what we'd need to have a standalone library. like, oops? accidental whole library 💀

Because of its background from nodepool, shade contained abstractions to work around deployment differences and is resource oriented rather than service oriented. This allows a user to think about Security Groups without having to know whether Security Groups are provided by Nova or Neutron on a given cloud. On the other hand, as an interface that provides an abstraction, it deviates from the published OpenStack REST API and adds its own opinions, which may not get in the way of more advanced users with specific needs. so: convenient, but opinionated. know that going in 🫶

os-client-config — os-client-config was a library for collecting client configuration for using an OpenStack cloud in a consistent and comprehensive manner, which introduced the clouds.yaml file for expressing named cloud configurations. yes THAT clouds.yaml. she invented it. mother behavior.

python-openstacksdk — python-openstacksdk was a library that exposed the OpenStack APIs to developers in a consistent and predictable manner.

After a while it became clear that there was value in both the high-level layer that contains additional business logic and the lower-level SDK that exposes services and their resources faithfully and consistently as Python objects. Even with both of those layers, it is still beneficial at times to be able to make direct REST calls and to do so with the same properly configured Session (http://docs.python-requests.org/en/master/user/advanced/#session-objects) from python-requests (http://docs.python-requests.org/en/master/). This led to the merge of the three projects. three become one. the avengers of Python OpenStack libraries, fr fr 🌈

The original contents of the shade library have been moved into openstack.cloud and os-client-config has been moved in to openstack.config. so if you're looking for the old stuff, that's where she lives now 💖

⭐ Contribution Mechanics ⭐

🧚 Contributing to openstacksdk 🧚

If you're interested in contributing to the openstacksdk project, the following will help get you started. come through, we'd love to have you 🫶✨

🎀 Developer Certificate of Origin

okay bestie, real talk: if you wanna contribute to openstacksdk, you have to adhere to the Developer Certificate of Origin (https://developercertificate.org/) — no cap. OpenStack uses the DCO as a lightweight way to confirm you're actually entitled to contribute the code you're submitting. This makes sure you're giving your contributions under the project's license and that you have the right to do it. 💖

Please read DeveloperWorkflow (https://docs.openstack.org/infra/manual/developers.html#development-workflow) before sending your first patch for review. And heads up: pull requests submitted through GitHub will be ignored. 💀

🦋 Project Hosting Details

Project Documentation — https://docs.openstack.org/openstacksdk/latest/
Bug tracker — https://bugs.launchpad.net/openstacksdk
Mailing list (prefix subjects with [sdk] for faster responses) — https://lists.openstack.org/mailman3/lists/openstack-discuss.lists.openstack.org/
Code Hosting — https://opendev.org/openstack/openstacksdk
Code Review — https://review.opendev.org/#/q/status:open+project:openstack/openstacksdk,n,z

💬 Contacting the Developers

🌈 IRC

The developers of this project are available in the #openstack-sdks channel on OFTC IRC (http://webchat.oftc.net?channels=%23openstack-sdks). This channel includes conversation on SDKs and tools within the general OpenStack community, including OpenStackClient as well as occasional talk about SDKs created for languages outside of Python. 🫶

📧 Email

The openstack-discuss mailing list (mailto:openstack-discuss@lists.openstack.org?subject=[sdk]%20Question%20about%20openstacksdk) fields questions of all types on OpenStack. Using the [sdk] filter to begin your email subject will ensure that the message gets to SDK developers. ✨

✨ Coding Standards

We are a bit stricter than usual in the coding standards department. It's a good idea to read through the coding <> section. 👑

👑 OpenStack SDK Developer Coding Standards

In the beginning, there were no guidelines. And it was good. But that didn't last long. As more and more people added more and more code, we realized that we needed a set of coding standards to make sure that the openstacksdk API at least attempted to display some form of consistency.

Thus, these coding standards/guidelines were developed. Note that not all of openstacksdk adheres to these standards just yet. Some older code has not been updated because we need to maintain backward compatibility. Some of it just hasn't been changed yet. But be clear: all new code must adhere to these guidelines. 💅

Below are the patterns that we expect openstacksdk developers to follow.

🍓 Release Notes

openstacksdk uses reno (https://docs.openstack.org/reno/latest/) for managing its release notes. A new release note should be added to your contribution anytime you add new API calls, fix significant bugs, add new functionality or parameters to existing API calls, or make any other significant changes to the code base that we should draw attention to for the user base.

It is not necessary to add release notes for minor fixes, such as correction of documentation typos, minor code cleanup or reorganization, or any other change that a user would not notice through normal usage. 🧚

💀 Exceptions

Exceptions should NEVER be wrapped and re-raised inside of a new exception. This removes important debug information from the user. All of the exceptions should be raised correctly the first time.

☁️ openstack.cloud API Methods

The openstack.cloud layer has some specific rules:

When an API call acts on a resource that has both a unique ID and a name, that API call should accept either identifier with a name_or_id parameter.
All resources should adhere to the get/list/search interface that control retrieval of those resources. E.g., get_image(), list_images(), search_images().
Resources should have create_RESOURCE(), delete_RESOURCE(), update_RESOURCE() API methods (as it makes sense).
For those methods that should behave differently for omitted or None-valued parameters, use the _utils.valid_kwargs decorator. This includes all Neutron update_* functions.
Deleting a resource should return True if the delete succeeded, or False if the resource was not found. 🫶

🌸 Returned Resources

The openstack.cloud layer should rely on the proxy layer for the given service. This will ensure complex objects returned to the caller are of openstack.resource.Resource type.

🌈 Nova vs. Neutron

Recognize that not all cloud providers support Neutron, so never assume it will be present. If a task can be handled by either Neutron or Nova, code it to be handled by either.
For methods that accept either a Nova pool or Neutron network, the parameter should just refer to the network, but documentation of it should explain about the pool. See: create_floating_ip() and available_floating_ip() methods.

🧚 Tests

New API methods must have unit tests!
New unit tests should only mock at the REST layer using requests_mock. Any mocking of openstacksdk itself should be considered legacy and to be avoided. Exceptions to this rule can be made when attempting to test the internals of a logical shim where the inputs and output of the method aren't actually impacted by remote content.
Functional tests should be added, when possible.
In functional tests, always use unique names (for resources that have this attribute) and use it for clean up (see next point).
In functional tests, always define cleanup functions to delete data added by your test, should something go wrong. Data removal should be wrapped in a try except block and try to delete as many entries added by the test as possible. 💜

🛠️ Development Environment

The first step towards contributing code and documentation is to setup your development environment. We use a pretty standard setup, but it is fully documented in our setup <> section.

🎀 Creating a Development Environment

🧰 Required Tools

Python — As the OpenStack SDK is developed in Python, you will need at least one version of Python installed. Our continuous integration system runs against several versions, so ultimately we will have the proper test coverage, but having multiple versions locally results in less time spent in code review when changes unexpectedly break other versions.

Python can be downloaded from https://www.python.org/downloads. 🐍

virtualenv — In order to isolate our development environment from the system-based Python installation, we use virtualenv (https://virtualenv.pypa.io/en/latest/). This allows us to install all of our necessary dependencies without interfering with anything else, and preventing others from interfering with us. Virtualenv must be installed on your system in order to use it, and it can be had from PyPI, via pip, as follows. Note that you may need to run this as an administrator in some situations.:

$ apt-get install python3-virtualenv  # Debian based platforms
$ dnf install python3-virtualenv      # Red Hat based platforms
$ pip install virtualenv              # Mac OS X and other platforms

You can create a virtualenv in any location. A common usage is to store all of your virtualenvs in the same place, such as under your home directory. To create a virtualenv for the default Python, run the following:

$ virtualenv $HOME/envs/sdk

To create an environment for a different version, run the following:

$ virtualenv -p python3 $HOME/envs/sdk3

When you want to enable your environment so that you can develop inside of it, you activate it. To activate an environment, run the /bin/activate script inside of it, like the following:

$ source $HOME/envs/sdk3/bin/activate
(sdk3)$

Once you are activated, you will see the environment name in front of your command prompt. In order to exit that environment, run the deactivate command. ✨

tox — We use tox (https://tox.readthedocs.org/en/latest/) as our test runner, which allows us to run the same test commands against multiple versions of Python. Inside any of the virtualenvs you use for working on the SDK, run the following to install tox into it.:

(sdk3)$ pip install tox

Git — The source of the OpenStack SDK is stored in Git. In order to work with our source repository, you must have Git installed on your system. If your system has a package manager, it can likely be had from there. If not, you can find downloads or the source at http://git-scm.com. 🌸

🦋 Getting the Source Code

Note: Before checking out the code, please read the OpenDev Developer's Guide (https://docs.opendev.org/opendev/infra-manual/latest/developers.html) for details on how to use the continuous integration and code review systems that we use.

The canonical Git repository is hosted on opendev.org at http://opendev.org/openstack/openstacksdk/:

(sdk3)$ git clone https://opendev.org/openstack/openstacksdk
(sdk3)$ cd openstacksdk

🍓 Installing Dependencies

In order to work with the SDK locally, such as in the interactive interpreter or to run example scripts, you need to install the project's dependencies.:

(sdk3)$ pip install -r requirements.txt

After the downloads and installs are complete, you'll have a fully functional environment to use the SDK in. 💖

🎀 Building the Documentation

Our documentation is written in reStructured Text and is built using Sphinx. A docs command is available in our tox.ini, allowing you to build the documentation like you'd run tests. The docs command is not evaluated by default.:

(sdk3)$ tox -e docs

That command will cause the documentation, which lives in the docs folder, to be built. HTML output is the most commonly referenced, which is located in docs/build/html. 🦋

💜 Testing

The project contains two test packages, one for unit tests and one for functional tests. The openstack.tests.unit package tests the SDK's features in isolation. The openstack.tests.functional package tests the SDK's features and examples against an OpenStack cloud.

💜 Testing (the tox one)

The tests are run with tox (https://tox.readthedocs.org/en/latest/) and configured in tox.ini. The test results are tracked by stestr (https://stestr.readthedocs.io/en/latest/) and configured in .stestr.conf and via command line options passed to the stestr executable when it's called by tox. 🔥

Unit Tests

Running tests

okay so bestie, if you wanna run the entire unit test suite, literally just run the tox command inside your source checkout. That's it. It'll attempt to run every test command listed inside tox.ini, which includes Python 3.x and a PEP 8 check. And listen — you should run the full suite on all versions before submitting changes for review, because otherwise the continuous integration system will surprise you with failures and nobody wants that energy 💀

$ tox
...
py3: commands succeeded
pep8: commands succeeded
congratulations :)

During development though, it's lowkey more convenient to run a subset of the tests so test time stays minimal. You can pick just one version to run on. And a step further than that: run only the tests you're actually working on 👑

# Run run the tests on Python 3.13
$ tox -e py313
# Run only the compute unit tests on Python 3.13
$ tox -e py313 openstack.tests.unit.compute
# Run only the tests in a specific file on Python 3.13
$ tox -e py313 -- -n openstack/tests/unit/compute/test_version.py

Functional Tests

so the functional tests assume you have a public or private OpenStack cloud you can run the tests against. The tests must be able to be run against public clouds, but first and foremost they must be run against OpenStack. In practice that means the tests should initially be run against a stable branch of DevStack — https://docs.openstack.org/devstack/latest/ ✨

Configuration

To connect the functional tests to an OpenStack cloud we require a clouds.yaml file, as discussed in Configuring OpenStack SDK Applications. You can place this clouds.yaml file in the root of your source checkout or in one of the other standard locations, $HOME/.config/openstack or /etc/openstack.

There must be at least three clouds configured — or rather, three accounts configured for the one cloud. Those accounts are:

An admin account, which defaults to devstack-admin but is configurable via the OPENSTACKSDK_OPERATOR_CLOUD environment variable,
A user account, which defaults to devstack but is configurable via the OPENSTACKSDK_DEMO_CLOUD environment variable, and
An alternate user account, which defaults to devstack-demo but is configurable via the OPENSTACKSDK_DEMO_CLOUD_ALT environment variable

In addition, you must indicate the names of the flavor and image that should be used for tests. These can be configured via OPENSTACKSDK_FLAVOR and OPENSTACKSDK_IMAGE environment variables or functional.flavor_name and functional.image_name settings in the clouds.yaml file, respectively.

Finally, you can configure the timeout for tests using the OPENSTACKSDK_FUNC_TEST_TIMEOUT environment variable (defaults to 300 seconds). Some test modules take specific timeout values. For example, all tests in openstack.tests.functional.compute will check for the OPENSTACKSDK_FUNC_TEST_TIMEOUT_COMPUTE environment variable before checking for OPENSTACKSDK_FUNC_TEST_TIMEOUT. 🫶

Note: Recent versions of DevStack will configure a suitable clouds.yaml file for you, which will be placed at /etc/openstack/clouds.yaml.

This is an example of a minimal configuration for a clouds.yaml that connects the functional tests to a DevStack instance 💅

clouds:
  devstack:
    auth:
      auth_url: http://xxx.xxx.xxx.xxx/identity
      password: password
      project_domain_id: default
      project_name: demo
      user_domain_id: default
      username: demo
    identity_api_version: '3'
    region_name: RegionOne
    volume_api_version: '3'
  devstack-admin:
    auth:
      auth_url: http://xxx.xxx.xxx.xxx/identity
      password: password
      project_domain_id: default
      project_name: admin
      user_domain_id: default
      username: admin
    region_name: RegionOne
  devstack-alt:
    auth:
      auth_url: http://xxx.xxx.xxx.xxx/identity
      password: password
      project_domain_id: default
      project_name: alt_demo
      user_domain_id: default
      username: alt_demo
    region_name: RegionOne
example:
  image_name: cirros-0.5.2-x86_64-disk
  flavor_name: m1.small

Replace xxx.xxx.xxx.xxx with the IP address or FQDN of your DevStack instance. no cap, that part matters 🌸

Running tests

functional tests are also run against multiple Python versions. In order to run the entire functional test suite against the default Python 3 version in your environment, run the tox -e functional command inside of your source checkout. This will attempt to run every test in the openstack/tests/functional directory. For example:

$ tox -e functional
...
functional: commands succeeded
congratulations :)

Project Layout

The project contains a top-level openstack package, which houses several modules that form the foundation upon which each service's API is built on. Under the openstack package are packages for each of those services, such as openstack.compute. 🦋

How the SDK is organized

The following diagram shows how the project is laid out.

openstack/
    connection.py
    resource.py
    compute/
        compute_service.py
        v2/
            server.py
            _proxy.py
    tests/
        compute/
            v2/
                test_server.py

Resource

The openstack.resource.Resource base class is the building block of any service implementation. Resource objects correspond to the resources each service's REST API works with, so the openstack.compute.v2.server.Server subclass maps to the compute service's https://openstack:1234/v2/servers resource. it's giving mapping 💖

The base Resource contains methods to support the typical CRUD operations supported by REST APIs, and handles the construction of URLs and calling the appropriate HTTP verb on the given Adapter.

Values sent to or returned from the service are implemented as attributes on the Resource subclass using component objects such as resource.Body, resource.Header and resource.URI, depending on where in the request or response the value lives. Each component is created with the exact name of what the API expects, and can optionally include a type to be validated against on requests. You should choose an attribute name that follows PEP-8, regardless of what the server-side expects, as the component becomes a mapping between the two. ✨

is_public = resource.Body('os-flavor-access:is_public', type=bool)

There are six additional attributes which the Resource class checks before making requests to the REST API. allow_create, allow_fetch, allow_commit, allow_delete, allow_head, and allow_list are set to True or False, and are checked before making the corresponding method call.

The base_path attribute should be set to the URL which corresponds to this resource. Many base_paths are simple, such as "/servers". For base_paths which are composed of non-static information, Python's string replacement is used, e.g., base_path = "/servers/%(server_id)s/ips".

resource_key and resources_key are attributes to set when a Resource returns more than one item in a response, or otherwise requires a key to obtain the response value. For example, the Server class sets resource_key = "server" as an individual Server is stored in a dictionary keyed with the singular noun, and resources_key = "servers" as multiple Servers are stored in a dictionary keyed with the plural noun in the response. iykyk 🎀

Proxy

Each service implements a Proxy class based on Proxy, within the openstack/<program_name>/vX/_proxy.py module. For example, the v2 compute service's Proxy exists in openstack/compute/v2/_proxy.py.

The Proxy class is based on Adapter.

class openstack.proxy.Proxy(session, *, service_type=None,
service_name=None, interface=None, region_name=None,
endpoint_override=None, version=None, auth=None, user_agent=None,
connect_retries=None, logger=None, allow=None, additional_headers=None,
client_name=None, client_version=None, allow_version_hack=None,
global_request_id=None, min_version=None, max_version=None,
default_microversion=None, status_code_retries=None,
retriable_status_codes=None, raise_exc=None, rate_limit=None,
concurrency=None, connect_retry_delay=None,
status_code_retry_delay=None, statsd_client=None, statsd_prefix=None,
prometheus_counter=None, prometheus_histogram=None,
influxdb_config=None, influxdb_client=None)

Bases: Adapter

Represents a service.

api_version — The API version. This is used as a descriminating attribute for type checking.
retriable_status_codes = None — HTTP status codes that should be retried by default. The number of retries is defined by the configuration in parameters called <service-type>_status_code_retries.

Each service's Proxy provides a higher-level interface for users to work with via a Connection instance. 🔥

Rather than requiring users to maintain their own Adapter and work with lower-level Resource objects, the Proxy interface offers a place to make things easier for the caller.

Each Proxy class implements methods which act on the underlying Resource classes which represent the service. For example:

def list_flavors(self, **params):
    return flavor.Flavor.list(self.session, **params)

This method is operating on the openstack.compute.v2.flavor.Flavor.list method. For the time being, it simply passes on the Adapter maintained by the Proxy, and returns what the underlying Resource.list method does. slay 💅

Cloud

The openstack.cloud package provides the high-level cloud abstraction layer, historically known as shade. Where the Proxy interface maps closely onto a single service's REST API, the cloud layer offers business-logic-oriented methods that often span multiple requests, or even multiple services, and that normalize the differences between clouds. 🌈

The layer is implemented as a collection of mixin classes, one per service area, under openstack/cloud/ — for example, _compute.py provides ComputeCloudMixin and _network.py provides NetworkCloudMixin. These mixins get smooshed together into the Connection class, so their methods are lowkey just there on a Connection instance, right next to all the service Proxy objects. Like, Connection.create_server may create a server, wait for it to become active, attach a floating IP, and hand you back a normalized result — orchestrating several lower-level Proxy and Resource calls on the caller's behalf. She's doing a lot of work so you don't have to 💅

Application authors are generally encouraged to use these high-level methods where they exist, and fall back to the Proxy interface for the operations the cloud layer doesn't cover.

🫶 Connection

The openstack.connection.Connection class builds on top of an openstack.config.cloud_region.CloudRegion object, and gives you a higher-level interface constructed from Proxy objects from each of the services.

The Connection class' primary purpose is to act as a high-level interface to this SDK, managing the lower-level connection bits and exposing the Resource objects through their corresponding Proxy object.

So if you've built proper Resource objects and implemented methods on the corresponding Proxy object, congrats bestie — the high-level interface to your service is now exposed. 🎉

✨ Adding Features ✨

Does this SDK not do what you need it to do? Is it missing a service? Are you a developer on another project who wants to add their service? You're in the right place, bb. Below are examples of how to add new features to the OpenStack SDK. 🛠️

🌸 Creating a New Resource

This guide walks you through how to add resources for a service.

🎀 Naming Conventions

Above all, names across this project conform to Python's naming standards, as laid out in PEP 8 (https://www.python.org/dev/peps/pep-0008/).

The relevant details we need to know are as follows:

Module names are lower case, and separated by underscores if there's more than one word. For example, openstack.object_store
Class names are capitalized, with no spacing, and each subsequent word is capitalized in a name. For example, ServerMetadata
Attributes on classes, including methods, are lower case and separated by underscores. For example, allow_list or get_data

🦋 Services

Services in the OpenStack SDK are named after their program name, not their code name. For example, the project everyone calls "Nova" is always called "compute" within this SDK. No cap.

This guide walks through creating a service for an OpenStack program called "Fake". Following our guidelines, the code for its service would live under the openstack.fake namespace. What follows is the creation of a Resource class for the "Fake" service.

🍓 Resources

Resources are named after the server-side resource, which is set in the base_path attribute of the resource class. This guide creates a resource class for the /fake server resource, so the resource module is called fake.py and the class is called Fake.

👑 An Example

openstack/fake/fake_service.py

# Apache 2 header omitted for brevity

from openstack import service_description
from openstack.fake.v2 import _proxy as _proxy_v2

class FakeService(service_description.ServiceDescription):
    """The fake service."""

    supported_versions = {
        '2': _proxy_v2.Proxy,
    }

openstack/fake/v2/fake.py

# Apache 2 header omitted for brevity

from openstack import resource

class Fake(resource.Resource):
    resource_key = "resource"
    resources_key = "resources"
    base_path = "/fake"

    allow_create = True
    allow_fetch = True
    allow_commit = True
    allow_delete = True
    allow_list = True
    allow_head = True

    #: The transaction date and time.
    timestamp = resource.Header("x-timestamp")
    #: The name of this resource.
    name = resource.Body("name", alternate_id=True)
    #: The value of the resource. Also available in headers.
    value = resource.Body("value", alias="x-resource-value")
    #: Is this resource cool? If so, set it to True.
    #: This is a multi-line comment about cool stuff.
    cool = resource.Body("cool", type=bool)

💜 `fake.Fake` Attributes

Each service's resources inherit from Resource, so they can override any of the base attributes to fit the way their particular resource operates. It's giving customizable, fr fr.

🌈 `resource_key` and `resources_key`

These attributes are set based on how your resource responds with data. The default values for each of these are None, which works fine when your resource returns a JSON body you can use directly without a top-level key, such as {"name": "Ernie Banks", ...}".

But our Fake resource returns JSON bodies that have the details of the resource one level deeper, such as {"resources": {"name": "Ernie Banks", ...}, {...}}. It does a similar thing with single resources, putting them inside a dictionary keyed on "resource".

By setting Fake.resource_key on line 7, we tell the Resource.create, Resource.fetch, and Resource.commit methods that we're either sending or receiving a resource that's in a dictionary with that key. ✨

By setting Fake.resources_key on line 8, we tell the Resource.list method that we're expecting to receive multiple resources inside a dictionary with that key.

⭐ `base_path`

The base_path is the URL we're gonna use to make requests for this resource. In this case, line 9 sets base_path = "/fake", which also corresponds to the name of our class, Fake.

Most resources follow this basic formula. Some cases are more complex, where the URL for requests has to contain some extra data. The volume service has several resources that make either basic requests or detailed requests, so they use base_path = "/volumes/%s(detailed)". Before a request is made, if detailed = True, they convert it to a string so the URL becomes /volumes/detailed. If it's False, they only send /volumes/. Sneaky but iconic.

🧚 The Service

Unlike resource_key, resources_key, and base_path, the service a resource belongs to is not declared on the resource itself. Instead, each service provides a ServiceDescription subclass — FakeService in fake_service.py — which maps each supported API version to the proxy that exposes the service's resources.

In fake_service.py we set supported_versions so that version 2 of the service is served by openstack.fake.v2._proxy.Proxy. The proxy ties the resources together and knows how to reach the service in the catalog, so that when a request is made, the appropriate URL can be constructed. 🎀

🔥 Supported Operations

The base Resource disallows all types of requests by default, requiring each resource to specify which requests they support. On lines 11-16, our Fake resource specifies that it'll work with all of the operations. Full send. 💀

In order to have the following methods work, you must allow the corresponding value by setting it to True:

create (openstack.resource.Resource.create) → set allow_create
delete (openstack.resource.Resource.delete) → set allow_delete
head (openstack.resource.Resource.head) → set allow_head
list (openstack.resource.Resource.list) → set allow_list
fetch (openstack.resource.Resource.fetch) → set allow_fetch
commit (openstack.resource.Resource.commit) → set allow_commit

An additional attribute to set is commit_method. It defaults to PUT, but some services use POST or PATCH to commit changes back to the remote resource. Noted. 🫡

🎀 Properties

The way resource classes communicate values between the user and the server is through a set of component objects. Each one is declared as a class attribute and maps an attribute on your Resource to a value that lives in a particular part of the request or response:

resource.Body — a value carried in the JSON request or response body.
resource.Header — a value carried in an HTTP header.
resource.URI — a value that is interpolated into the base_path.
resource.Computed — a value that is computed locally rather than sent to or received from the server.

The first argument to each component is the name the value has on the server; the attribute name is how you refer to it in Python.

Line 19 declares a Header for timestamp, which will cause the Fake.timestamp attribute to contain the value returned in the x-timestamp header, such as from a Fake.head request.

Line 21 declares a Body for name, which is a value returned in a body, such as from a Fake.fetch request. Passing alternate_id=True marks this attribute as the resource's identifier, so when this resource is populated from a response, Fake.name and Fake.id are the same value. ✨

Line 23 declares a Body with an alias. Fake.value will be set when a response body contains a value, or when a header contains x-resource-value. Two-for-one, we love to see it.

Line 26 passes type=bool, which is checked before sending the value in a request. In this case, we can only set Fake.cool to either True or False — otherwise a TypeError will be raised if the value can't be converted to the expected type. 🚨

🎀 Documentation 🎀

Okay so for the API docs, we use Sphinx's autodoc feature to build them for every single resource we expose. Easy. The attributes you override from Resource <#openstack.resource.Resource>? Those don't need documenting. But any component attributes (Body, Header, and so on) absolutely do. 💅

All you gotta do is drop a comment above the line you want to document, with a colon following the pound-sign. That's the whole trick.

Lines 18, 20, 22, and 24-25 are comments that will then show up in the API documentation. And as you can see on lines 24 & 25, these comments can span multiple lines — no cap, they really can. ✨

🦋 Creating a Proxy 🦋

This guide walks you through adding a proxy for a service. It builds on the Creating a New Resource <> guide: where a Resource <#openstack.resource.Resource> maps onto a single server-side resource, a Proxy <#openstack.proxy.Proxy> gives you the higher-level, user-facing interface for a whole service. A Proxy is what a user actually reaches through a Connection <#openstack.connection.Connection> — like, conn.compute is the compute service's Proxy. iconic behaviour honestly.

🌸 Layout 🌸

Each service implements a single Proxy class per API version, in a module named _proxy.py:

openstack/<service>/v<N>/_proxy.py — the proxy, e.g. openstack/compute/v2/_proxy.py.
openstack/<service>/v<N>/<resource>.py — one module per resource type that the proxy operates on, e.g. flavor.py, server.py.

The class is always named Proxy and subclasses openstack.proxy.Proxy <#openstack.proxy.Proxy>. It declares an api_version discriminator and imports each resource module under an underscore-prefixed alias, so we don't get namespace collisions. Obsessed with a tidy namespace fr.

from typing import ClassVar, Literal

from openstack.fake.v2 import fake as _fake
from openstack import proxy

class Proxy(proxy.Proxy):
    api_version: ClassVar[Literal['2']] = '2'

💜 Base Helpers 💜

openstack.proxy.Proxy <#openstack.proxy.Proxy> subclasses keystoneauth1.adapter.Adapter — so a proxy is literally an authenticated HTTP client 💅 — and bolts on a set of generic helpers that delegate to the corresponding methods on your Resource <#openstack.resource.Resource> classes. Each one takes the resource class as its first argument:

_create — Create a resource from keyword attributes.
_get — Fetch a single resource by ID or instance.
_list — Return a generator over resources, with pagination and query filtering.
_find — Look a resource up by name or ID.
_update — Commit changes to a resource.
_delete — Delete a resource.
_head — Issue a HEAD request for a resource.
_get_resource — Normalize an ID, dict, or existing instance into a Resource instance. Used directly when a method needs an instance to call a resource action on.

Because these helpers do all the actual work, most proxy methods are just thin little wrappers that pick the right resource class and pass the caller's arguments straight through. lowkey elegant 🫶

⭐ Methods ⭐

Proxy methods follow a consistent naming and shape. A create, get, list, and delete for a Fake resource look like this:

def create_fake(self, **attrs):
    """Create a new fake from attributes

    :param attrs: Keyword arguments which will be used to create a
        :class:`~openstack.fake.v2.fake.Fake`, comprised of the properties
        on the Fake class.

    :returns: The results of fake creation.
    """
    return self._create(_fake.Fake, **attrs)

def get_fake(self, fake):
    """Get a single fake

    :param fake: The value can be the ID of a fake or a
        :class:`~openstack.fake.v2.fake.Fake` instance.

    :returns: One :class:`~openstack.fake.v2.fake.Fake`
    :raises: :class:`~openstack.exceptions.NotFoundException` when no
        resource can be found.
    """
    return self._get(_fake.Fake, fake)

def fakes(self, **query):
    """Return a generator of fakes

    :param query: Optional query parameters to be sent to limit the
        resources being returned.

    :returns: A generator of fake objects.
    """
    return self._list(_fake.Fake, **query)

def delete_fake(self, fake, ignore_missing=True):
    """Delete a fake

    :param fake: The value can be either the ID of a fake or a
        :class:`~openstack.fake.v2.fake.Fake` instance.
    :param ignore_missing: When set to ``False``
        :class:`~openstack.exceptions.NotFoundException` will be raised
        when the fake does not exist. When set to ``True``, no exception
        will be raised when attempting to delete a nonexistent fake.

    :returns: ``None``
    """
    self._delete(_fake.Fake, fake, ignore_missing=ignore_missing)

Note the conventions, bestie 👑:

Methods that accept a resource take "either the ID ... or a instance", and document it that way.
Deletes and finds take an ignore_missing argument, defaulting to True.
List methods are named after the plural noun (fakes) and return a generator; the other methods are named <verb>_<resource>.
Docstrings use Sphinx field lists (:param:, :returns:, :raises:) and cross-reference the concrete resource class with :class:~...`` so only the short name renders.

For actions that aren't simple CRUD, use _get_resource to grab an instance and then call a method on the resource itself. periodt. 🔥

🌈 Wiring the Proxy to a Connection 🌈

A proxy gets exposed on the Connection <#openstack.connection.Connection> through a ServiceDescription <#openstack.service_description.ServiceDescription>, as introduced in the Creating a New Resource <> guide. The description maps each supported API version to its proxy class:

from openstack.fake.v2 import _proxy
from openstack import service_description

class FakeService(service_description.ServiceDescription):
    """The fake service."""

    supported_versions = {
        '2': _proxy.Proxy,
    }

Finally, the service has to be registered so it becomes an attribute on every Connection <#openstack.connection.Connection>. The registry lives in the generated file openstack/_services_mixin.py, where each service is declared with the connection attribute name and its service_type:

fake = fake_service.FakeService(service_type='fake')

⚠️ Do not edit openstack/_services_mixin.py by hand — regenerate it by running tools/print-services.py.

Once it's registered, conn.fake returns a lazily constructed instance of your Proxy. Slay. 💖

🧚 Creating an Authentication Plugin 🧚

Note: openstacksdk does not implement its own authentication plugins. It delegates entirely to keystoneauth1 <https://docs.openstack.org/keystoneauth/latest/>. If you want to add a new authentication mechanism, you implement it in keystoneauth1, not here. This guide just explains how openstacksdk consumes auth plugins, so you know what's required to make a new plugin usable from openstacksdk. iykyk.

🍓 How openstacksdk consumes auth plugins 🍓

Authentication is configured through the auth_type and auth keys of a cloud's configuration (see Auth Settings <#config-auth-settings>). When a Connection <#openstack.connection.Connection> gets built, openstacksdk resolves and loads the plugin named by auth_type using keystoneauth1's loading machinery. The relevant code lives in OpenStackConfig._get_auth_loader (in openstack/config/loader.py), which ultimately calls keystoneauth1.loading.get_plugin_loader(auth_type) and then instantiates the plugin with loader.load_from_options(**auth).

A few friendly aliases are handled by openstacksdk before the name is passed to keystoneauth1 — for example, an empty auth_type maps to none and token_endpoint maps to admin_token — but every real plugin, including the default, password, is provided by keystoneauth1. openstacksdk registers no plugins of its own and ships no keystoneauth1.plugin entry points. Not a single one. 💀

🦋 Adding a new mechanism 🦋

Because the loading is entirely delegated, adding a new authentication mechanism requires no changes to openstacksdk. Instead:

Implement the plugin and its loader in keystoneauth1, following the keystoneauth plugin documentation <https://docs.openstack.org/keystoneauth/latest/authentication-plugins.html>.
Register it under the keystoneauth1.plugin entry-point group (this is how get_plugin_loader discovers plugins by name).
Once the package providing the plugin is installed alongside openstacksdk, it can be selected from clouds.yaml simply by setting auth_type to your plugin's name, with its options under the auth key:

clouds:
  my-cloud:
    auth_type: my-plugin
    auth:
      # options declared by your plugin's loader
      ...

For the full set of authentication options and worked examples of the plugins that ship with keystoneauth1, see Auth Settings <#config-auth-settings>. go off 💅✨

💫 GENERAL INFORMATION 💫

okay bestie, this is like the reference zone — the glossary and the release-history bits. it's giving "the appendix but make it fashion." all the actual definitions are here, i'm just making them fun to read 🫶

🌸 Glossary 🌸

CLI — Command-Line Interface; a textual user interface. yes, the thing you're literally looking at right now, bestie. meta 💅
compute — OpenStack Compute (Nova). that's the service's actual name in the docs, don't @ me.
container — one of the object-store resources; a container holds objects being stored. it's the folder energy of the object store, lowkey.
endpoint — a base URL used in a REST request. and there are two flavours, so pay attention: an authentication endpoint is specifically the URL given to a user to identify a cloud. a service endpoint is generally obtained from the service catalog. two different vibes, same word 😭
host — a physical computer. contrast with node and server. that's the whole definition, no cap.
identity — OpenStack Identity (Keystone). iconic. runs the whole "who are you" situation.
image — OpenStack Image (Glance). also the attribute name of the disk files stored for use by servers. double duty, main character energy ⭐
keypair — the attribute name of the SSH public key used in the OpenStack Compute API for server authentication. your lil key, absolutely slaying your auth for you 🔑
node — a logical system, may refer to a server (virtual machine) or a host.

and like, generally it's used to describe an OS instance where a specific process is running, e.g. a network node is where the network processes run, and may be directly on a host or in a server. contrast with host and server. three words, all slightly different, all out to get you 🙈

object — a generic term which normally refers to the a Python object. (yes, "the a" — that's exactly how the page says it, i'm not touching it, it's canon now 💀) the OpenStack Object Store service (Swift) also uses object as the name of the item being stored within a container. so: python object = code thing, swift object = your actual file. context is everything.
object-store — OpenStack Object Store (Swift). storage but make it cloudy ☁️
project — the name of the owner of resources in an OpenStack cloud. a project can map to a customer, account or organization in different OpenStack deployments. and bestie, it's used instead of the deprecated tenant. we don't say tenant anymore, we moved on 💅
region — the attribute name of a partitioning of cloud resources. geographic-ish, vibes-wise.
resource — a Python object representing an OpenStack resource inside the SDK code. also used to describe the items managed by OpenStack. again: two meanings, one word. stay vigilant ✨
role — a personality that a user assumes when performing a specific set of operations. a role includes a set of rights and privileges that a user assuming that role inherits. the OpenStack Identity service includes the set of roles that a user can assume in the token that is issued to that user.

and here's the important bit, so listen up: the individual services determine how the roles are interpreted and access granted to operations or resources. the OpenStack Identity service treats a role as an arbitrary name assigned by the cloud administrator. so like, identity doesn't police what a role means — it's just a name. your actual permissions depend on the service. periodt 👑

server — a virtual machine or a bare-metal host managed by the OpenStack Compute service. contrast with host and node. (third time's the charm, the trio is complete 🎀)
service — in OpenStack this refers to a service/endpoint in the ServiceCatalog. it could also be a collection of endpoints for different regions. a service has a type and a name. two attributes, no notes.
service catalog — the list of services configured at a given authentication endpoint available to the authenticated user. it's like the menu of what your cloud will let you order off of 🍓
tenant — deprecated in favor of project. that's it. that's the definition. she's retired, respect her legacy 🕊️
token — an arbitrary bit of text that is used to access resources. some tokens are scoped to determine what resources are accessible with it. a token may be revoked at any time and is valid for a finite duration. ⚠️ so don't get attached — it can vanish whenever and it has an expiry date, fr fr.
volume — OpenStack Volume (Cinder). also the attribute name of the virtual disks managed by the OpenStack Volume service. your disks, but cloud-flavoured 💾

🌈 Release Notes 🌈

release notes for openstacksdk can be found at https://releases.openstack.org/teams/openstacksdk.html — go read them, they're right there, i'm just the messenger 💖

🦋 Author 🦋

Author name not set. yeah. the page literally says that. mysterious icon behaviour, honestly — anonymous but make it legendary 🙈

🎀 Copyright 🎀

2017, Various members of the OpenStack Foundation — that's the whole credit line, keep it accurate bestie 🫶

aaaand that's the whole page, we made it to the end together!! 🥳 this little beauty is openstacksdk version 4.22.0, and the footer date says Jan 02, 1980 — yes, 1980, which is older than the concept of the cloud itself, but honestly? slay, we stan a retro timestamp 💀✨ go forth and cloud responsibly, mwah 💜

📦 where this page comes from

nixpkgs unstable: python3.13-openstacksdk 4.22.0
nixpkgs unstable: python3.14-openstacksdk 4.22.0
💖 girlified by deepseek-ai/DeepSeek-V4.1-Flash-1017 on 2026-11-04: a language model's rewrite of the original, under its terms

OPENSTACKSDK(1)

NAME 🌸

INSTALLATION ✨

Installation guide 🎀

FOR USERS 🫶

Using the OpenStack SDK 💅

User Guides 🧚

Getting started 🌈

Using os-client-config 🛠️

Configuring OpenStack SDK Applications ⚙️

Environment Variables 💻

Config Files 📁

Splitting Secrets 🤫

Example 🌟

Vendor Profiles 🏷️

Auth Settings 🎀

MFA Support 🫶

API Settings ✨

SSL Settings 🔐

Cache Settings 🍓

IPv6 🦋

Service-specific Overrides 💅

Per-region settings 🌸

💅 Setting Precedence

🌸 Examples

auth

🦋 Using openstack.config in an Application

Usage

argparse

🌈 Vendor Support

Default Values

AURO

Betacloud

Binero

Catalyst

☁️ City Cloud

🌸 ConoHa

🦋 DreamCompute

👑 Open Telekom Cloud

✨ ELASTX

🎀 Enter Cloud Suite

🍓 Fuga

💜 Internap

🌈 Limestone Networks

💫 OVH

⭐ Rackspace

🌸 Switch Cloud 🌸

🦋 SWITCHengines 🦋

🎀 Ultimum 🎀

⭐ UnitedStack ⭐

💜 VEXXHOST 💜

🌈 Zetta 🌈

🧚 Network Config 🧚

📚 API Reference 📚

get_one_cloud_osc(cloud=None, validate=True, argparse=None, **kwargs)

static set_one_cloud(config_file, cloud, set_config=None)

class openstack.config.cloud_region.CloudRegion(...)

property full_name

set_session_constructor(session_constructor)

get_requests_verify_args()

get_services()

get_endpoint_from_catalog(service_type, interface=None, region_name=None)

get_auth()

clear_auth_cache()

insert_user_agent()

✨ get_session()

✨ get_service_catalog()

✨ get_all_version_data(service_type)

✨ get_session_client(service_type, version=None, constructor=None, **kwargs)

✨ get_session_endpoint(service_type, min_version=None, max_version=None)

✨ get_cache_resource_expiration(resource, default=None)

✨ requires_floating_ip()

✨ get_external_networks()

✨ get_external_ipv4_networks()

✨ get_external_ipv6_networks()

✨ get_internal_networks()

✨ get_internal_ipv4_networks()

✨ get_internal_ipv6_networks()

✨ get_default_network()

✨ get_nat_destination()

`get_one_cloud_osc(cloud=None, validate=True, argparse=None, **kwargs)`

`static set_one_cloud(config_file, cloud, set_config=None)`

`class openstack.config.cloud_region.CloudRegion(...)`

property `full_name`

`set_session_constructor(session_constructor)`

`get_requests_verify_args()`

`get_services()`

`get_endpoint_from_catalog(service_type, interface=None, region_name=None)`

`get_auth()`

`clear_auth_cache()`

`insert_user_agent()`

✨ `get_session()`

✨ `get_service_catalog()`

✨ `get_all_version_data(service_type)`

✨ `get_session_client(service_type, version=None, constructor=None, **kwargs)`

✨ `get_session_endpoint(service_type, min_version=None, max_version=None)`

✨ `get_cache_resource_expiration(resource, default=None)`

✨ `requires_floating_ip()`

✨ `get_external_networks()`

✨ `get_external_ipv4_networks()`

✨ `get_external_ipv6_networks()`

✨ `get_internal_networks()`

✨ `get_internal_ipv4_networks()`

✨ `get_internal_ipv6_networks()`

✨ `get_default_network()`

✨ `get_nat_destination()`

✨ `get_nat_source()`

✨ `get_client_config(name=None, defaults=None)`