sf-python-logo SolidFire Python SDK

Python SDK library for interacting with SolidFire Element API

pypy python format downloads license

Current Release

Version 1.7.0.124

Description

The SolidFire Python SDK is a collection of libraries that facilitate integration and orchestration between proprietary systems and third-party applications. The Python SDK allows developers to deeply integrate SolidFire system API with the Python programming language. The SolidFire Python SDK reduces the amount of additional coding time required for integration.

Compatibility

Component Version
SolidFire Element OS 10.0 - 12.2

Getting Help

If you have any questions or comments about this product, contact ng-sf-host-integrations-sdk@netapp.com or reach out to the online developer community at ThePub. Your feedback helps us focus our efforts on new features and capabilities.

Documentation

Release Notes

Installation

From PyPI

pip install solidfire-sdk-python

From Source

Note: It is recommended using virtualenv for isolating the python environment to only the required libraries.

Alternatively, for development purposes or to inspect the source, the following will work:

git clone git@github.com:solidfire/solidfire-sdk-python.git
cd solidfire-sdk-python
git checkout develop
pip install -e ".[dev, test, docs, release]"
python setup.py install

Then append the location of this directory to the PYTHONPATH environment variable to use the SDK in other python scripts:

export PYTHONPATH=$PYTHONPATH:/path/to/sf-python-sdk/

That’s it – you are ready to start interacting with your SolidFire cluster using Python!

Examples

Step 1 - Build an Element object using the factory

This is the preferred way to construct the Element object. The factory will make a call to the SolidFire cluster using the credentials supplied to test the connection. It will also set the version to communicate with based on the highest number supported by the SDK and Element OS. Optionally, you can choose to set the version manually and whether or not to verify SSL. Read more about it in the ElementFactory documentation.

from solidfire.factory import ElementFactory

# Use ElementFactory to get a SolidFireElement object.
sfe = ElementFactory.create("ip-address-of-cluster", "username", "password")

Step 2 - Call the API method and retrieve the result

All service methods in SolidFireElement call API endpoints and they all return result objects. The naming convention is [method_name]_result. For example, list_accounts returns a list_accounts_result object which has a property called accounts that can be iterated.

This example sends a request to list accounts then pulls the first account from the add_account_result object.

# Send the request and wait for the result then pull the AccountID
list_accounts_result = sfe.list_accounts()
account = list_accounts_result.accounts[0];

More examples using the Python SDK

from solidfire.factory import ElementFactory

# Create connection to SF Cluster
sfe = ElementFactory.create("ip-address-of-cluster", "username", "password")

# --------- EXAMPLE 1 - CREATE AN ACCOUNT -----------
# Send the request with required parameters and gather the result
add_account_result = sfe.add_account(username="example-account")
# Pull the account ID from the result object
account_id = add_account_result.account_id

# --------- EXAMPLE 2 - CREATE A VOLUME -------------
# Send the request with required parameters and gather the result
create_volume_result = sfe.create_volume(name="example-volume",
                                         account_id=account_id,
                                         total_size=1000000000,
                                         enable512e=False)
# Pull the VolumeID off the result object
volume_id = create_volume_result.volume_id

# --------- EXAMPLE 3 - LIST ONE VOLUME FOR AN ACCOUNT -------------
# Send the request with desired parameters and pull the first volume in the
# result
volume = sfe.list_volumes(accounts=[account_id], limit=1).volumes[0]
# pull the iqn from the volume
iqn = volume.iqn

# --------- EXAMPLE 3 - MODIFY A VOLUME -------------
# Send the request with the desired parameters
sfe.modify_volume(volume_id=volume_id, total_size=2000000000)

More Examples

More specific examples are available here

Logging

To configure logging responses, execute the following:

import logging
from solidfire import common
common.setLogLevel(logging.DEBUG)

To access the logger for the Element instance:

from solidfire.common import LOG

Timeouts

Connection timeout (useful for failing fast when a host becomes unreachable):

from solidfire.factory import ElementFactory
sfe = ElementFactory.create("ip-address-of-cluster", "username", "password")
sfe.timeout(600)

Read timeout (useful for extending time for a service call to return):

from solidfire.factory import ElementFactory
sfe = ElementFactory.create("ip-address-of-cluster", "username", "password")
sf.read_timeout(600)

License

Copyright © 2020, 2021 NetApp, Inc. All rights reserved.

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.

Account Management Examples

Manage Accounts

These examples walk through all interactions with an Account on the SolidFire cluster.

Examples for:

Documentation

Further documentation for each method and type can be found in our PyPI documentation repository.

List all Accounts

To list all accounts on a cluster:

from solidfire.factory import ElementFactory

# Create connection to SF Cluster
sfe = ElementFactory.create("ip-address-of-cluster", "username", "password")

# Send the request and gather the result
list_accounts_result = sfe.list_accounts()

# iterate the accounts array on the result object and display each Account
for account in list_accounts_result.accounts:
    print(account)

Get one Account

To get a single account by ID:

from solidfire.factory import ElementFactory

# Create connection to SF Cluster
sfe = ElementFactory.create("ip-address-of-cluster", "username", "password")

# Send the request with a specific account id and gather the result
get_account_result = sfe.get_account_by_id(1)

# Display the account from the result object
print(get_account_result.account)

To get a single account by username:

from solidfire.factory import ElementFactory

# Create connection to SF Cluster
sfe = ElementFactory.create("ip-address-of-cluster", "username", "password")

# Send the request with a specific account username and gather the result
get_account_result = sfe.get_account_by_name('username-of-account')

# Display the account from the result object
print(get_account_result.account)

Create an Account

To create an account you must specify the username. Optionally, you can also specify the initiator_secret and target_secret which are CHAPSecret objects. If those secrets are not specified, they will be auto-generated.

First, we create an account with only a username:

from solidfire.factory import ElementFactory

# Create connection to SF Cluster
sfe = ElementFactory.create("ip-address-of-cluster", "username", "password")

# Send the request and gather the result
add_account_result = sfe.add_account(username="my-new-account")

# Grab the account ID from the result object
new_account_id = add_account_result.account_id

Now we create an account and specify the username and initiator_secret. Notice we created a new CHAPSecret object and set the string value for the intitiator_secret. The target_secret will be auto-generated during the process on the cluster:

from solidfire.factory import ElementFactory
from solidfire import CHAPSecret

# Create connection to SF Cluster
sfe = ElementFactory.create("ip-address-of-cluster", "username", "password")

# Send the request and gather the result
add_account_result = sfe.add_account(username="my-new-account",
                                     initiator_secret=CHAPSecret(
                                         "a12To16CharValue"))
# The initiator and target secrets can be set many different ways
# Below are more examples
# Passing strings into add account.
add_account_result = sfe.add_account("my-new-account", "a12To16CharValue")
# Passing string into CHAPSecret() as a parameter
add_account_result = sfe.add_account("my-new-account", CHAPSecret("a12To16CharValue"))
# Explicitly setting 'secret' in CHAPSecret()
add_account_result = sfe.add_account("my-new-account", CHAPSecret(secret="a12To16CharValue"))
# Creating a kwarg for secret and passing it in
kwarg = {"secret":"a12To16CharValue"}
add_account_result = sfe.add_account("my-new-account", CHAPSecret(**kwarg))

# Grab the account ID from the result object
new_account_id = add_account_result.account_id

Modify an Account

To modify an account, all you need is the account_id and the values you want to change. Any values you leave off will remain as they were before this call is made.

In this example, we will instruct the API to autogenerate a new target_secret value for an account. In order to do so we need to call the static auto_generate() method on the CHAPSecret class.

from solidfire.factory import ElementFactory
from solidfire import CHAPSecret

# Create connection to SF Cluster
sfe = ElementFactory.create("ip-address-of-cluster", "username", "password")

# Send the request with the account_id and gather the result
add_account_result = sfe.modify_account(account_id=1,
                                        target_secret=CHAPSecret.auto_generate())

Snapshot Scheduling Examples

Snapshot Scheduling

These examples walk through all interactions with a Schedule. Schedules control when automatic Snapshots will be taken of volumes on the SolidFire cluster.

Examples for:

Documentation

Further documentation for each method and type can be found in our PyPI documentation repository.

List all Schedules

To list all the schedules on a cluster:

from solidfire.factory import ElementFactory

# Create connection to SF Cluster
sfe = ElementFactory.create("ip-address-of-cluster", "username", "password")

# Send the request and gather the result
list_schedules_result = sfe.list_schedules()

# iterate the schedules array on the result object and display each Schedule
for schedule in list_schedules_result.schedules:
    print(schedule)

Get one Schedule

To get a single schedule:

from solidfire.factory import ElementFactory

# Create connection to SF Cluster
sfe = ElementFactory.create("ip-address-of-cluster", "username", "password")

# Send the request with the schedule_id and gather the result
get_schedule_result = sfe.get_schedule(schedule_id=56)

# Display the schedule from the result object
print(get_schedule_result.schedule)

Create a Schedule

In order for automatic snapshots to be taken, you need to create a schedule. There are three types of schedules that can be created:

All three types of schedules are demonstrated here:

Time Interval Schedule

This type of schedule will base snapshots on a time interval frequency. Each snapshot will be taken after the specified amount of time has passed. Control the duration by setting days, hours, and minutes on the TimeIntervalFrequency object.

from solidfire.custom.models import TimeIntervalFrequency
from solidfire.models import Schedule

sched = Schedule()
sched.name = "SnapshotEvery3AndAHalfDays"
sched.frequency = TimeIntervalFrequency(days=3, hours=12)

Days Of Week Schedule

This type of schedule will base snapshots on a weekly frequency. Each snapshot will be taken on the specified weekdays at the time specified in the hours and minutes properties. Control the schedule by setting weekdays, hours, and minutes on the DaysOfWeekFrequency object.

from solidfire.custom.models import DaysOfWeekFrequency, Weekday
from solidfire.models import Schedule

sched = Schedule()
sched.name = "SnapshotOnMonWedFriAt3am"
sched.frequency = DaysOfWeekFrequency(
            weekdays=[
                Weekday.from_name("Monday"),
                Weekday.from_name("Wednesday"),
                Weekday.from_name("Friday")],
            hours=3)

Days Of Month Schedule

This type of schedule will base snapshots on a monthly frequency. Each snapshot will be taken on the specified month days at the time specified in the hours and minutes properties. Control the schedule by setting monthdays, hours, and minutes on the DaysOfMonthFrequency object.

from solidfire.custom.models import DaysOfMonthFrequency
from solidfire.models import Schedule

sched = Schedule()
sched.name = "SnapshotOn7th14thAnd21stAt0130Hours"
sched.frequency = DaysOfMonthFrequency(
            monthdays=[7,14,21],
            hours=3,
            monutes=30)

Create a Schedule (cont.)

After creating the schedule and setting the frequency to Time Interval, Days Of Week, or Days Of Month, complete the object by setting the schedule_info property. This controls information about the resulting snapshot such as which volumes are in it, its name, and how long it should be retained.

Continuing on with the Time Interval example from above:

from solidfire.custom.models import TimeIntervalFrequency
from solidfire.models import Schedule, ScheduleInfo
from solidfire.factory import ElementFactory

sched = Schedule()
sched.name = "SnapshotEvery12Hours"
sched.frequency = TimeIntervalFrequency(hours=12)
sched.schedule_info = ScheduleInfo(
    volume_ids = [1, 3, 5],
    snapshot_name = '12th hour snapshot',
    retention="72:00:00" # in HH:mm:ss format
)
# When should the schedule start?
sched.starting_date = "2016-12-01T00:00:00Z"

# Create connection to SF Cluster
sfe = ElementFactory.create("ip-address-of-cluster", "username", "password")

# Call the create_schedule method with the newly created schedule object
create_schedule_result = sfe.create_schedule(sched)

# Grab the schedule ID from the result object
new_schedule_id = create_schedule_result.schedule_id

At this point we have created a new schedule called SnapshotEvery12Hours that creates a snapshot whose name is prepended with “12th hour snapshot” every 12 hours for volumes 1, 3, and 5 that is retained for 72 hours.

Modify a Schedule

To modify a schedule, first you must have a valid schedule object with its schedule_id set. You can create one manually but it is preferred to retrieve it from the cluster, modify the properties needed and then send it back. Here is an example:

from solidfire.factory import ElementFactory

# Create connection to SF Cluster
sfe = ElementFactory.create("ip-address-of-cluster", "username", "password")

# Send the request with the schedule_id and gather the result
get_schedule_result = sfe.get_schedule(schedule_id=new_schedule_id)

# set a schedule variable from the schedule in the result for ease of use
sched = get_schedule_result.schedule

# display the retrieved schedule
print(sched)

# set paused to True in order to pause the schedule
sched.paused = True

# send the request to modify this schedule
sfe.modify_schedule(sched)

# Send another get_schedule request and gather the result
get_modified_schedule_result = sfe.get_schedule(schedule_id=new_schedule_id)

# display the newly modified schedule
print(get_modified_schedule_result.schedule)

This is the output:

Schedule(frequency=TimeIntervalFrequency(days=0, hours=12, minutes=0), has_error=False, last_run_status='Success', last_run_time_start=None, name='SnapshotsEvery12Hours', paused=False, recurring=False, run_next_interval=False, schedule_id=56, schedule_info=ScheduleInfo(enable_remote_replication=None, retention='72:00:00', snapshot_name='12th hour snapshot', volume_ids='[1, 3, 5]'), starting_date='2016-12-01T00:00:00Z', to_be_deleted=False)

Schedule(frequency=TimeIntervalFrequency(days=0, hours=12, minutes=0), has_error=False, last_run_status='Success', last_run_time_start=None, name='SnapshotsEvery12Hours', paused=True, recurring=False, run_next_interval=False, schedule_id=56, schedule_info=ScheduleInfo(enable_remote_replication=None, retention='72:00:00', snapshot_name='12th hour snapshot', volume_ids='[1, 3, 5]'), starting_date='2016-12-01T00:00:00Z', to_be_deleted=False)

Notice the paused field changes from False to True

Enum Support Examples

Enum Support

These examples walk through all interactions with an Enums on the SolidFire cluster.

Examples for:

List all Enums

AuthConfigType

AuthConfigType This type indicates the configuration data which will be accessed or modified by the element auth container.:

from solidfire.models import AuthConfigType

#mNode authentication configuration data.
    sfe = models.AuthConfigType("mNode")

#Element authentication configuration data.
        sfe = models.AuthConfigType("element")

#Returns String type values.
        value=sfe.get_value()

DriveEncryptionCapabilityType

This specifies a drive’s encryption capability.

from solidfire.models import DriveEncryptionCapabilityType

#Drive is not a Self Encrypting Drive (SED), and therefore not FIPS.
        sfe = models.DriveEncryptionCapabilityType("none")

#Drive is a SED but not a FIPS SED.
        sfe = models.DriveEncryptionCapabilityType("sed")

#Drive is a FIPS SED Drive.
        sfe = models.DriveEncryptionCapabilityType("fips")

#Returns String type values.
        value=sfe.get_value()

FipsDrivesStatusType

This specifies a node’s FIPS 140-2 compliance status.

from solidfire.models import FipsDrivesStatusType

#Node is not FIPS capable.
        sfe = models.FipsDrivesStatusType("none")

#Node is FIPS capable but not all drives present are FIPS drives.
        sfe = models.FipsDrivesStatusType("partial")

#Node is FIPS capable and all drives present are FIPS drives or if there are no drives present.
        sfe = models.FipsDrivesStatusType("ready")

#Returns String type values.
        value=sfe.get_value()

ProposedNodeErrorCode

This specifies error code for a proposed node addition.

from solidfire.models import ProposedNodeErrorCode

#Nodes constitute too large a portion of cluster capacity for protectionScheme=doubleHelix.
        sfe = models.ProposedNodeErrorCode("nodesTooLarge")

#Nodes failed to authenticate.
        sfe = models.ProposedNodeErrorCode("nodesAuthError")

#Nodes did not respond to ping requests.
        sfe = models.ProposedNodeErrorCode("nodesUnreachable")

#Unable to add a non-FIPS capable node to cluster while FipsDrives Feature is enabled.
        sfe = models.ProposedNodeErrorCode("nonFipsNodeCapable")

#Unable to add a node with non-FIPS capable drive(s) to cluster while FipsDrives Feature is enabled.
        sfe = models.ProposedNodeErrorCode("nonFipsDrivesCapable")

#Returns String type values.
        value=sfe.get_value()

ProtectionDomainType

A Protection Domain is a set of one or more components whose simultaneous failure is protectedfrom causing data unavailability or loss. This specifies one of the types of Protection Domains recognized by this cluster.

from solidfire.models import ProtectionDomainType

#Any individual Node.
        sfe = models.ProtectionDomainType("node")

#Any individual Node or all storage Nodes within an individual HCI chassis.
        sfe = models.ProtectionDomainType("chassis")

#Any or all Nodes that have been assigned the same CustomProtectionDomainName.
        sfe = models.ProtectionDomainType("custom")

#Returns String type values.
        value=sfe.get_value()

ProtectionScheme

The method of protecting data on the cluster

from solidfire.models import ProtectionScheme


        sfe = models.ProtectionScheme("singleHelix")

        sfe = models.ProtectionScheme("doubleHelix")

        sfe = models.ProtectionScheme("tripleHelix")

#Returns String type values.
        value=sfe.get_value()

ProtectionSchemeCategory

The category of the protection scheme.

from solidfire.models import ProtectionSchemeCategory

#The protection scheme is replication based.
        sfe = models.ProtectionSchemeCategory("helix")

#The protection scheme is erasure-coding based.
        sfe = models.ProtectionSchemeCategory("erasureCoded")

#Returns String type values.
        value=sfe.get_value()

ProtectionSchemeVisibility

The public visibility of the protection scheme.

from solidfire.models import ProtectionSchemeVisibility

#The scheme is publicly released for customer use.
        sfe = models.ProtectionSchemeVisibility("customer")

#The scheme is for internal test use only.
        sfe = models.ProtectionSchemeVisibility("testOnly")

#Returns String type values.
        value=sfe.get_value()

RemoteClusterSnapshotStatus

Status of the remote snapshot on the target cluster as seen on the source cluster.

from solidfire.models import RemoteClusterSnapshotStatus

#Snapshot exists on the target cluster
        sfe = models.RemoteClusterSnapshotStatus("Present")

#Snapshot does not exist on the target cluster
        sfe = models.RemoteClusterSnapshotStatus("Not Present")

#Snapshot is currently replicating to the target cluster
        sfe = models.RemoteClusterSnapshotStatus("Syncing")

#Snapshot has been deleted on the target, and it still exists on the source
        sfe = models.RemoteClusterSnapshotStatus("Deleted")

#The status of snapshot on the target is not known on the source
        sfe = models.RemoteClusterSnapshotStatus("Unknown")

#Returns String type values.
        value=sfe.get_value()

VolumeAccess

Describes host access for a volume.

from solidfire.models import VolumeAccess

#No reads or writes are allowed.
        sfe = models.VolumeAccess("locked")

#Only read operations are allowed.
        sfe = models.VolumeAccess("readOnly")

#Reads and writes are allowed.
        sfe = models.VolumeAccess("readWrite")

#Designated as a target volume in a replicated volume pair.
        sfe = models.VolumeAccess("replicationTarget")

#Controlled by a SnapMirror endpoint. No reads or writes are allowed.
        sfe = models.VolumeAccess("snapMirrorTarget")

#Returns String type values.
        value=sfe.get_value()

solidfire package

Submodules

solidfire.factory module

class solidfire.factory.ElementFactory[source]

The Factory for creating a SolidFire Element object.

static create(target, username, password, version=None, verify_ssl=False, port=443, print_ascii_art=True, timeout=30)[source]
Factory method to create a Element object which is used to call
the SolidFire API. This method runs multiple checks and logic to ensure the Element object creation is valid for the cluster you are attempting to connect to. It is preferred to use this factory method over the standard constructor.
Parameters:
  • target (str) – the target IP or hostname of the cluster or node.
  • username (str) – username used to connect to the Element OS instance.
  • password (str) – authentication for username
  • version (float or str) – specific version of Element OS to connect to. If this doesn’t match the cluster or is outside the versions supported by this SDK, you will get an exception.
  • verify_ssl (bool) – enable this to check ssl connection for errors especially when using a hostname. It is invalid to set this to true when using an IP address in the target.
  • port (int) – a port to connect to if other than 443, which is the default for a SolidFire cluster. Specify 442 if connecting to a SoldiFire node.
  • print_ascii_art (bool) – When True, print the SolidFire Robot to the log. Production deployments might consider disabling this feature.
  • timeout (int) – The number of seconds to wait before timing out a request.
Returns:

a configured and tested instance of Element

Raises:

SdkOperationError: verify_ssl is true but target is an IP address SdkOperationError: version is unable to be determined as float ApiVersionUnsupportedError: version is not supported by

instance of Element OS.

solidfire.models module

class solidfire.models.AbortSnapMirrorRelationshipRequest(snap_mirror_endpoint_id, destination_volume, clear_checkpoint=None)[source]

Bases: solidfire.common.model.DataObject

The SolidFire Element OS web UI uses the AbortSnapMirrorRelationship method to stop SnapMirror transfers that have started but are not yet complete.

Parameters:
  • snap_mirror_endpoint_id (int) – [required] The endpoint ID of the remote ONTAP storage system communicating with the SolidFire cluster.
  • destination_volume (SnapMirrorVolumeInfo) – [required] The destination volume in the SnapMirror relationship.
  • clear_checkpoint (bool) – Determines whether or not to clear the restart checkpoint.
clear_checkpoint = <type 'bool'>
destination_volume = <class 'solidfire.models.SnapMirrorVolumeInfo'>
snap_mirror_endpoint_id = <type 'int'>
class solidfire.models.AbortSnapMirrorRelationshipResult(snap_mirror_relationship)[source]

Bases: solidfire.common.model.DataObject

Parameters:snap_mirror_relationship (SnapMirrorRelationship) – [required] An object containing information about the aborted SnapMirror relationship.
snap_mirror_relationship = <class 'solidfire.models.SnapMirrorRelationship'>
class solidfire.models.Account(account_id, username, status, volumes, initiator_secret=None, target_secret=None, storage_container_id=None, attributes=None, enable_chap=None)[source]

Bases: solidfire.common.model.DataObject

The object containing information about an account. This object only includes “configured” information about the account, not any runtime or usage information.

Parameters:
  • account_id (int) – [required] Unique AccountID for the account.
  • username (str) – [required] User name for the account.
  • status (str) – [required] Current status of the account.
  • volumes (int) – [required] List of VolumeIDs for Volumes owned by this account.
  • initiator_secret (CHAPSecret) – CHAP secret to use for the initiator.
  • target_secret (CHAPSecret) – CHAP secret to use for the target (mutual CHAP authentication).
  • storage_container_id (UUID) – The id of the storage container associated with the account
  • attributes (dict) – List of Name/Value pairs in JSON object format.
  • enable_chap (bool) – Specify if chap account credentials can be used by an initiator to access volumes.
account_id = <type 'int'>
attributes = <type 'dict'>
enable_chap = <type 'bool'>
initiator_secret = <class 'solidfire.models.CHAPSecret'>
status = <type 'str'>
storage_container_id = <class 'uuid.UUID'>
target_secret = <class 'solidfire.models.CHAPSecret'>
username = <type 'str'>
volumes = <type 'int[]'>
class solidfire.models.AddAccountRequest(username, initiator_secret=None, target_secret=None, attributes=None, enable_chap=None)[source]

Bases: solidfire.common.model.DataObject

You can use AddAccount to add a new account to the system. You can create new volumes under the new account. The CHAP settings you specify for the account apply to all volumes owned by the account.

Parameters:
  • username (str) – [required] Specifies the username for this account. (Might be 1 to 64 characters in length).
  • initiator_secret (CHAPSecret) – The CHAP secret to use for the initiator. If unspecified, a random secret is created.
  • target_secret (CHAPSecret) – The CHAP secret to use for the target (mutual CHAP authentication). If unspecified, a random secret is created.
  • attributes (dict) – List of name-value pairs in JSON object format.
  • enable_chap (bool) – Specify if chap account credentials can be used by an initiator to access volumes.
attributes = <type 'dict'>
enable_chap = <type 'bool'>
initiator_secret = <class 'solidfire.models.CHAPSecret'>
target_secret = <class 'solidfire.models.CHAPSecret'>
username = <type 'str'>
class solidfire.models.AddAccountResult(account_id, account=None)[source]

Bases: solidfire.common.model.DataObject

Parameters:
  • account_id (int) – [required] AccountID for the newly created Account.
  • account (Account) – The full account object
account = <class 'solidfire.models.Account'>
account_id = <type 'int'>
class solidfire.models.AddClusterAdminRequest(username, password, access, accept_eula, attributes=None)[source]

Bases: solidfire.common.model.DataObject

You can use AddClusterAdmin to add a new cluster admin account. A cluster ddmin can manage the cluster using the API and management tools. Cluster admins are completely separate and unrelated to standard tenant accounts. Each cluster admin can be restricted to a subset of the API. NetApp recommends using multiple cluster admin accounts for different users and applications. You should give each cluster admin the minimal permissions necessary; this reduces the potential impact of credential compromise. You must accept the End User License Agreement (EULA) by setting the acceptEula parameter to true to add a cluster administrator account to the system.

Parameters:
  • username (str) – [required] Unique username for this cluster admin. Must be between 1 and 1024 characters in length.
  • password (str) – [required] Password used to authenticate this cluster admin.
  • access (str) – [required] Controls which methods this cluster admin can use. For more details on the levels of access, see Access Control in the Element API Reference Guide.
  • accept_eula (bool) – [required] Required to indicate your acceptance of the End User License Agreement when creating this cluster. To accept the EULA, set this parameter to true.
  • attributes (dict) – List of name-value pairs in JSON object format.
accept_eula = <type 'bool'>
access = <type 'str[]'>
attributes = <type 'dict'>
password = <type 'str'>
username = <type 'str'>
class solidfire.models.AddClusterAdminResult(cluster_admin_id)[source]

Bases: solidfire.common.model.DataObject

Parameters:cluster_admin_id (int) – [required] ClusterAdminID for the newly created Cluster Admin.
cluster_admin_id = <type 'int'>
class solidfire.models.AddDrivesRequest(drives)[source]

Bases: solidfire.common.model.DataObject

AddDrives enables you to add one or more available drives to the cluster, enabling the drives to host a portion of the cluster’s data. When you add a node to the cluster or install new drives in an existing node, the new drives are marked as “available” and must be added via AddDrives before they can be utilized. Use the ListDrives method to display drives that are “available” to be added. When you add multiple drives, it is more efficient to add them in a single AddDrives method call rather than multiple individual methods with a single drive each. This reduces the amount of data balancing that must occur to stabilize the storage load on the cluster. When you add a drive, the system automatically determines the “type” of drive it should be. The method is asynchronous and returns immediately. However, it can take some time for the data in the cluster to be rebalanced using the newly added drives. As the new drives are syncing on the system, you can use the ListSyncJobs method to see how the drives are being rebalanced and the progress of adding the new drive. You can also use the GetAsyncResult method to query the method’s returned asyncHandle.

Parameters:drives (NewDrive) – [required] Returns information about each drive to be added to the cluster. Possible values are: driveID: The ID of the drive to add. (Integer) type: (Optional) The type of drive to add. Valid values are “slice” or “block”. If omitted, the system assigns the correct type. (String)
drives = <class 'solidfire.models.NewDrive[]'>
class solidfire.models.AddDrivesResult(async_handle=None)[source]

Bases: solidfire.common.model.DataObject

Parameters:async_handle (int) –
async_handle = <type 'int'>
class solidfire.models.AddIdpClusterAdminRequest(username, access, accept_eula, attributes=None)[source]

Bases: solidfire.common.model.DataObject

Adds a cluster administrator user authenticated by a third party Identity Provider (IdP). IdP cluster admin accounts are configured based on SAML attribute-value information provided within the IdP’s SAML assertion associated with the user. If a user successfully authenticates with the IdP and has SAML attribute statements within the SAML assertion matching multiple IdP cluster admin accounts, the user will have the combined access level of those matching IdP cluster admin accounts.

Parameters:
  • username (str) – [required] A SAML attribute-value mapping to a IdP cluster admin (e.g. email=test@example.com). This could be defined using a specific SAML subject using NameID, or an entry in the SAML attribute statement such as eduPersonAffiliation.
  • access (str) – [required] Controls which methods this IdP Cluster Admin can use. For more details on the levels of access, see the Access Control appendix in the SolidFire API Reference.
  • accept_eula (bool) – [required] Accept the End User License Agreement. Set to true to add a cluster administrator account to the system. If omitted or set to false, the method call fails.
  • attributes (dict) – List of name-value pairs in JSON object format.
accept_eula = <type 'bool'>
access = <type 'str[]'>
attributes = <type 'dict'>
username = <type 'str'>
class solidfire.models.AddInitiatorsToVolumeAccessGroupRequest(volume_access_group_id, initiators)[source]

Bases: solidfire.common.model.DataObject

AddInitiatorsToVolumeAccessGroup enables you to add initiators to a specified volume access group.

Parameters:
  • volume_access_group_id (int) – [required] The ID of the volume access group to modify.
  • initiators (str) – [required] The list of initiators to add to the volume access group.
initiators = <type 'str[]'>
volume_access_group_id = <type 'int'>
class solidfire.models.AddKeyServerToProviderKmipRequest(key_provider_id, key_server_id)[source]

Bases: solidfire.common.model.DataObject

Adds (assigns) the specified KMIP (Key Management Interoperability Protocol) Key Server to the specified Key Provider. This will result in contacting the server to verify it’s functional, as well as to synchronize keys in the event that there are multiple key servers assigned to the provider. This synchronization may result in conflicts which could cause this to fail. If the specified KMIP Key Server is already assigned to the specified Key Provider, this is a no-op and no error will be returned. The assignment can be removed (unassigned) using RemoveKeyServerFromProviderKmip.

Parameters:
  • key_provider_id (int) – [required] The ID of the Key Provider to assign the KMIP Key Server to.
  • key_server_id (int) – [required] The ID of the KMIP Key Server to assign.
key_provider_id = <type 'int'>
key_server_id = <type 'int'>
class solidfire.models.AddKeyServerToProviderKmipResult[source]

Bases: solidfire.common.model.DataObject

There is no additional data returned as the add is considered successful as long as there is no error.

class solidfire.models.AddLdapClusterAdminRequest(username, access, accept_eula=None, attributes=None)[source]

Bases: solidfire.common.model.DataObject

AddLdapClusterAdmin enables you to add a new LDAP cluster administrator user. An LDAP cluster administrator can manage the cluster via the API and management tools. LDAP cluster admin accounts are completely separate and unrelated to standard tenant accounts. You can also use this method to add an LDAP group that has been defined in Active Directory. The access level that is given to the group is passed to the individual users in the LDAP group.

Parameters:
  • username (str) – [required] The distinguished user name for the new LDAP cluster admin.
  • access (str) – [required] Controls which methods this Cluster Admin can use. For more details on the levels of access, see the Access Control appendix in the SolidFire API Reference.
  • accept_eula (bool) – Accept the End User License Agreement. Set to true to add a cluster administrator account to the system. If omitted or set to false, the method call fails.
  • attributes (dict) – List of name-value pairs in JSON object format.
accept_eula = <type 'bool'>
access = <type 'str[]'>
attributes = <type 'dict'>
username = <type 'str'>
class solidfire.models.AddLdapClusterAdminResult(cluster_admin_id=None)[source]

Bases: solidfire.common.model.DataObject

Parameters:cluster_admin_id (int) –
cluster_admin_id = <type 'int'>
class solidfire.models.AddNodesRequest(pending_nodes, auto_install=None)[source]

Bases: solidfire.common.model.DataObject

AddNodes enables you to add one or more new nodes to a cluster. When a node that is not configured starts up for the first time, you are prompted to configure the node. After you configure the node, it is registered as a “pending node” with the cluster. Note: It might take several seconds after adding a new node for it to start up and register its drives as available.

Parameters:
  • pending_nodes (int) – [required] List of pending NodeIDs for the nodes to be added. You can obtain the list of pending nodes using the ListPendingNodes method.
  • auto_install (bool) – If true, RTFI will be performed on the nodes. The default behavior is to perform RTFI.
auto_install = <type 'bool'>
pending_nodes = <type 'int[]'>
class solidfire.models.AddNodesResult(nodes, auto_install=None)[source]

Bases: solidfire.common.model.DataObject

Parameters:
  • auto_install (bool) –
  • nodes (AddedNode) – [required] An array of objects mapping the previous “pendingNodeID” to the “nodeID”.
auto_install = <type 'bool'>
nodes = <class 'solidfire.models.AddedNode[]'>
class solidfire.models.AddVirtualNetworkRequest(virtual_network_tag, name, address_blocks, netmask, svip, gateway=None, namespace=None, attributes=None)[source]

Bases: solidfire.common.model.DataObject

You can use the AddVirtualNetwork method to add a new virtual network to a cluster configuration. When you add a virtual network, an interface for each node is created and each interface will require a virtual network IP address. The number of IP addresses you specify as a parameter for this API method must be equal to or greater than the number of nodes in the cluster. The system bulk provisions virtual network addresses and assigns them to individual nodes automatically. You do not need to assign virtual network addresses to nodes manually. Note: You can use AddVirtualNetwork only to create a new virtual network. If you want to make changes to an existing virtual network, use ModifyVirtualNetwork. Note: Virtual network parameters must be unique to each virtual network when setting the namespace parameter to false.

Parameters:
  • virtual_network_tag (int) – [required] A unique virtual network (VLAN) tag. Supported values are 1 through 4094.The number zero (0) is not supported.
  • name (str) – [required] A user-defined name for the new virtual network.
  • address_blocks (AddressBlockParams) – [required] Unique range of IP addresses to include in the virtual network. Attributes for this parameter are: start: The start of the IP address range. (String) size: The number of IP addresses to include in the block. (Integer)
  • netmask (str) – [required] Unique network mask for the virtual network being created.
  • svip (str) – [required] Unique storage IP address for the virtual network being created.
  • gateway (str) – The IP address of a gateway of the virtual network. This parameter is valid only if the namespace parameter is set to true (meaning VRF is enabled).
  • namespace (bool) – When set to true, enables the Routable Storage VLANs functionality by recreating the virtual network and configuring a namespace to contain it. When set to false, disables the VRF functionality for the virtual network. Changing this value disrupts traffic running through this virtual network.
  • attributes (dict) – List of name-value pairs in JSON object format.
address_blocks = <class 'solidfire.models.AddressBlockParams[]'>
attributes = <type 'dict'>
gateway = <type 'str'>
name = <type 'str'>
namespace = <type 'bool'>
netmask = <type 'str'>
svip = <type 'str'>
virtual_network_tag = <type 'int'>
class solidfire.models.AddVirtualNetworkResult(virtual_network_id=None)[source]

Bases: solidfire.common.model.DataObject

Parameters:virtual_network_id (int) – The virtual network ID of the new virtual network.
virtual_network_id = <type 'int'>
class solidfire.models.AddVolumesToVolumeAccessGroupRequest(volume_access_group_id, volumes)[source]

Bases: solidfire.common.model.DataObject

AddVolumesToVolumeAccessGroup enables you to add volumes to a specified volume access group.

Parameters:
  • volume_access_group_id (int) – [required] The ID of the volume access group to which volumes are added.
  • volumes (int) – [required] The list of volumes to add to the volume access group.
volume_access_group_id = <type 'int'>
volumes = <type 'int[]'>
class solidfire.models.AddedNode(pending_node_id, node_id=None, active_node_key=None, assigned_node_id=None, async_handle=None, cip=None, mip=None, platform_info=None, sip=None, software_version=None)[source]

Bases: solidfire.common.model.DataObject

Parameters:
  • node_id (int) –
  • pending_node_id (int) – [required]
  • active_node_key (str) –
  • assigned_node_id (int) –
  • async_handle (int) –
  • cip (str) –
  • mip (str) –
  • platform_info (Platform) –
  • sip (str) –
  • software_version (str) –
active_node_key = <type 'str'>
assigned_node_id = <type 'int'>
async_handle = <type 'int'>
cip = <type 'str'>
mip = <type 'str'>
node_id = <type 'int'>
pending_node_id = <type 'int'>
platform_info = <class 'solidfire.models.Platform'>
sip = <type 'str'>
software_version = <type 'str'>
class solidfire.models.AddressBlock(start, size, available)[source]

Bases: solidfire.common.model.DataObject

Unique Range of IP addresses to include in the virtual network.

Parameters:
  • start (str) – [required] Start of the IP address range.
  • size (int) – [required] Number of IP addresses to include in the block.
  • available (str) – [required] Nuber of available blocks
available = <type 'str'>
size = <type 'int'>
start = <type 'str'>
class solidfire.models.AddressBlockParams(start, size, available)[source]

Bases: solidfire.common.model.DataObject

Unique Range of IP addresses to include in the virtual network.

Parameters:
  • start (str) – [required] Start of the IP address range.
  • size (int) – [required] Number of IP addresses to include in the block.
  • available (str) – [required] dynamic bitset
available = <type 'str'>
size = <type 'int'>
start = <type 'str'>
class solidfire.models.AsyncHandle(async_result_id, completed, create_time, last_update_time, result_type, success, data)[source]

Bases: solidfire.common.model.DataObject

Parameters:
  • async_result_id (int) – [required] The ID of the result.
  • completed (bool) – [required] Returns true if it is completed and false if it isn’t.
  • create_time (str) – [required] The time at which the asyncronous result was created
  • last_update_time (str) – [required] Time at which the result was last updated
  • result_type (str) – [required] The type of result. Could be Clone, DriveAdd, etc.
  • success (bool) – [required] Returns whether the result was a success or failure.
  • data (dict) – [required] Attributes related to the result
async_result_id = <type 'int'>
completed = <type 'bool'>
create_time = <type 'str'>
data = <type 'dict'>
last_update_time = <type 'str'>
result_type = <type 'str'>
success = <type 'bool'>
class solidfire.models.AsyncHandleResult(async_handle)[source]

Bases: solidfire.common.model.DataObject

Parameters:async_handle (int) – [required]
async_handle = <type 'int'>
class solidfire.models.AuthConfigType(value)[source]

Bases: solidfire.common.model.DataObject

This type indicates the configuration data which will be accessed or modified by the element auth container.

enum_values = (u'mNode', u'element')
get_value()[source]
class solidfire.models.AuthMethod(value)[source]

Bases: solidfire.common.model.DataObject

This type qualifies a ClusterAdmin with its authentication method.

enum_values = (u'Cluster', u'Ldap', u'Idp')
get_value()[source]
class solidfire.models.AuthSessionInfo(cluster_admin_ids, username, session_id, session_creation_time, final_timeout, last_access_timeout, access_group_list, auth_method, idp_config_version)[source]

Bases: solidfire.common.model.DataObject

Contains a information about an auth session.

Parameters:
  • cluster_admin_ids (int) – [required] Cluster AdminID(s) associated with this session. For sessions related to LDAP or a third party Identity Provider (IdP), this will be an aggregate list of matching Cluster AdminIDs associated with this session.
  • username (str) – [required] Username associated with this session. For sessions related to LDAP this will be the user’s LDAP DN. For sessions related to a third party Identity Provider (IdP), this will be an arbitrary name-value pair that will be used for auditing operations within the session. It will not necessarily match a cluster admin name on the cluster. For example, a SAML Subject NameID, but this will be dictated by the configuration of the IdP and the resultant content of the SAML assertion.
  • session_id (UUID) – [required] UUID for this session.
  • session_creation_time (str) – [required] Time at which the session was created.
  • final_timeout (str) – [required] Time at which the session becomes invalid. This is set when the session is created and cannot be changed.
  • last_access_timeout (str) – [required] Time at which the session becomes invalid due to inactivity. It is set to a new value when the session is accessed for use, up to the time where the session becomes invalid due to finalTimeout being reached.
  • access_group_list (str) – [required] List of access groups for the user.
  • auth_method (AuthMethod) – [required] Method in which the cluster admin was authenticated.
  • idp_config_version (int) – [required] IdP configuration version when the session was created.
access_group_list = <type 'str[]'>
auth_method = <class 'solidfire.models.AuthMethod'>
cluster_admin_ids = <type 'int[]'>
final_timeout = <type 'str'>
idp_config_version = <type 'int'>
last_access_timeout = <type 'str'>
session_creation_time = <type 'str'>
session_id = <class 'uuid.UUID'>
username = <type 'str'>
class solidfire.models.BackupTarget(name, backup_target_id, attributes=None)[source]

Bases: solidfire.common.model.DataObject

The object containing information about a backup target.

Parameters:
  • name (str) – [required] Name for the backup target.
  • backup_target_id (int) – [required] Unique identifier assigned to the backup target.
  • attributes (dict) – List of Name/Value pairs in JSON object format.
attributes = <type 'dict'>
backup_target_id = <type 'int'>
name = <type 'str'>
class solidfire.models.BinAssignmentProperties(algorithm_runtime_ms, are_replicas_valid, bin_count, is_balanced, is_stable, num_updating_bins, num_swaps, layout, reason, replication_count, request_rebalance, protection_domain_type, service_stranded_capacities, valid_schemes, time_published=None)[source]

Bases: solidfire.common.model.DataObject

Parameters:
  • algorithm_runtime_ms (int) – [required] Time in milliseconds taken to calculate this bin assignments.
  • are_replicas_valid (bool) – [required] If replicas are valid in bin assignments.
  • bin_count (int) – [required] Number of bins assigned.
  • is_balanced (bool) – [required] If replica assignments are balanced across all block services.
  • is_stable (bool) – [required] If bin assignments are not expected to change.
  • num_updating_bins (int) – [required] Number of bins that have status bsUpdating or bsUdpatingFromActive.
  • num_swaps (int) – [required] Number of replicas that were swapped.
  • layout (ProtectionDomainServiceReplicaBudget) – [required] Replica bin budget for each block service in a protection domain.
  • reason (str) – [required] Reason for this bin assignments.
  • replication_count (int) – [required] Number of replicas per bin.
  • request_rebalance (bool) – [required] If bin assignments are requested to be rebalanced, which is expected during drive recovery.
  • protection_domain_type (ProtectionDomainType) – [required] Protection domain type
  • service_stranded_capacities (ServiceStrandedCapacity) – [required] Stranded capacities for block services
  • time_published (str) – When bin assignments were published.
  • valid_schemes (GetProtectionSchemesResult) – [required] Valid data protection schemes.
algorithm_runtime_ms = <type 'int'>
are_replicas_valid = <type 'bool'>
bin_count = <type 'int'>
is_balanced = <type 'bool'>
is_stable = <type 'bool'>
layout = <class 'solidfire.models.ProtectionDomainServiceReplicaBudget[]'>
num_swaps = <type 'int'>
num_updating_bins = <type 'int'>
protection_domain_type = <class 'solidfire.models.ProtectionDomainType'>
reason = <type 'str'>
replication_count = <type 'int'>
request_rebalance = <type 'bool'>
service_stranded_capacities = <class 'solidfire.models.ServiceStrandedCapacity[]'>
time_published = <type 'str'>
valid_schemes = <class 'solidfire.models.GetProtectionSchemesResult[]'>
class solidfire.models.BlockSizeHistogram(bucket512_to4095, bucket4096to8191, bucket8192_to16383, bucket16384_to32767, bucket32768_to65535, bucket65536_to131071, bucket131072_plus)[source]

Bases: solidfire.common.model.DataObject

Parameters:
  • bucket512_to4095 (int) – [required] Number of block size samples between 512 and 4095 bytes
  • bucket4096to8191 (int) – [required] Number of block size samples between 4096 and 8191 bytes
  • bucket8192_to16383 (int) – [required] Number of block size samples between 8192 and 16383 bytes
  • bucket16384_to32767 (int) – [required] Number of block size samples between 16384 and 32767 bytes
  • bucket32768_to65535 (int) – [required] Number of block size samples between 32768 and 65535 bytes
  • bucket65536_to131071 (int) – [required] Number of block size samples between 65536 and 131071 bytes
  • bucket131072_plus (int) – [required] Number of block size samples greater than or equal to 131072 bytes
bucket131072_plus = <type 'int'>
bucket16384_to32767 = <type 'int'>
bucket32768_to65535 = <type 'int'>
bucket4096to8191 = <type 'int'>
bucket512_to4095 = <type 'int'>
bucket65536_to131071 = <type 'int'>
bucket8192_to16383 = <type 'int'>
class solidfire.models.BreakSnapMirrorRelationshipRequest(snap_mirror_endpoint_id, destination_volume)[source]

Bases: solidfire.common.model.DataObject

The SolidFire Element OS web UI uses the BreakSnapMirrorRelationship method to break a SnapMirror relationship. When a SnapMirror relationship is broken, the destination volume is made read-write and independent, and can then diverge from the source. You can reestablish the relationship with the ResyncSnapMirrorRelationship API method. This method requires the ONTAP cluster to be available.

Parameters:
  • snap_mirror_endpoint_id (int) – [required] The endpoint ID of the remote ONTAP storage system communicating with the SolidFire cluster.
  • destination_volume (SnapMirrorVolumeInfo) – [required] The destination volume in the SnapMirror relationship.
destination_volume = <class 'solidfire.models.SnapMirrorVolumeInfo'>
snap_mirror_endpoint_id = <type 'int'>
class solidfire.models.BreakSnapMirrorRelationshipResult(snap_mirror_relationship)[source]

Bases: solidfire.common.model.DataObject

Parameters:snap_mirror_relationship (SnapMirrorRelationship) – [required] An object containing information about the broken SnapMirror relationship.
snap_mirror_relationship = <class 'solidfire.models.SnapMirrorRelationship'>
class solidfire.models.BreakSnapMirrorVolumeRequest(volume_id, snapshot_id=None, preserve=None, access=None)[source]

Bases: solidfire.common.model.DataObject

The SolidFire Element OS web UI uses the BreakSnapMirrorVolume method to break the SnapMirror relationship between an ONTAP source container and SolidFire target volume. Breaking a SolidFire SnapMirror volume is useful if an ONTAP system becomes unavailable while replicating data to a SolidFire volume. This feature enables a storage administrator to take control of a SolidFire SnapMirror volume, break its relationship with the remote ONTAP system, and revert the volume to a previous snapshot.

Parameters:
  • volume_id (int) – [required] The volume on which to perform the break operation. The volume access mode must be snapMirrorTarget.
  • snapshot_id (int) – Roll back the volume to the snapshot identified by this ID. The default behavior is to roll back to the most recent snapshot.
  • preserve (bool) – Preserve any snapshots newer than the snapshot identified by snapshotID. Possible values: true: Preserve snapshots newer than snapshotID. false: Do not preserve snapshots newer than snapshotID. If false, any snapshots newer than snapshotID are deleted.
  • access (str) – Resulting volume access mode. Possible values: readWrite readOnly locked
access = <type 'str'>
preserve = <type 'bool'>
snapshot_id = <type 'int'>
volume_id = <type 'int'>
class solidfire.models.BreakSnapMirrorVolumeResult[source]

Bases: solidfire.common.model.DataObject

class solidfire.models.BulkVolumeJob(bulk_volume_id, create_time, elapsed_time, format, key, percent_complete, remaining_time, src_volume_id, status, type, attributes, script=None, snapshot_id=None)[source]

Bases: solidfire.common.model.DataObject

Parameters:
  • bulk_volume_id (int) – [required] The internal bulk volume job ID.
  • create_time (str) – [required] Timestamp created for the bulk volume job.
  • elapsed_time (int) – [required] The number of seconds since the job began.
  • format (str) – [required] Format is either “compressed” or “native”.
  • key (str) – [required] The unique key created by the bulk volume session.
  • percent_complete (int) – [required] The completed percentage reported by the operation.
  • remaining_time (int) – [required] The estimated time remaining in seconds.
  • src_volume_id (int) – [required] The source volume ID.
  • status (str) – [required] Can be one of the following: preparing active done failed
  • script (str) – The name of the script if one is provided.
  • snapshot_id (int) – ID of the snapshot if a snapshot is in the source of the bulk volume job.
  • type (str) – [required] Can be one of the following: read write
  • attributes (dict) – [required] JSON attributes on the bulk volume job.
attributes = <type 'dict'>
bulk_volume_id = <type 'int'>
create_time = <type 'str'>
elapsed_time = <type 'int'>
format = <type 'str'>
key = <type 'str'>
percent_complete = <type 'int'>
remaining_time = <type 'int'>
script = <type 'str'>
snapshot_id = <type 'int'>
src_volume_id = <type 'int'>
status = <type 'str'>
type = <type 'str'>
class solidfire.models.CHAPSecret(**kwargs)[source]

Bases: solidfire.custom.models.CHAPSecret

class solidfire.models.CancelCloneRequest(clone_id)[source]

Bases: solidfire.common.model.DataObject

CancelClone enables you to stop an ongoing CloneVolume or CopyVolume process. When you cancel a group clone operation, the system completes and removes the operation’s associated asyncHandle.

Parameters:clone_id (int) – [required] The cloneID for the ongoing clone process.
clone_id = <type 'int'>
class solidfire.models.CancelCloneResult[source]

Bases: solidfire.common.model.DataObject

class solidfire.models.CancelGroupCloneRequest(group_clone_id)[source]

Bases: solidfire.common.model.DataObject

CancelGroupClone enables you to stop an ongoing CloneMultipleVolumes process occurring on a group of volumes. When you cancel a group clone operation, the system completes and removes the operation’s associated asyncHandle.

Parameters:group_clone_id (int) – [required] The cloneID for the ongoing clone process.
group_clone_id = <type 'int'>
class solidfire.models.CancelGroupCloneResult[source]

Bases: solidfire.common.model.DataObject

class solidfire.models.CheckProposedClusterRequest(nodes)[source]

Bases: solidfire.common.model.DataObject

CheckProposedCluster validates that creating a cluster from a given set of nodes is likely to succeed. Any problems with the proposed cluster are returned as errors with a human-readable description and unique error code.

Parameters:nodes (str) – [required] List of node IPs for the nodes in the new cluster.
nodes = <type 'str[]'>
class solidfire.models.CheckProposedNodeAdditionsRequest(nodes)[source]

Bases: solidfire.common.model.DataObject

CheckProposedNodeAdditions validates that adding a node (or nodes) to an existing cluster is likely to succeed. Any problems with the proposed new cluster are returned as errors with a human-readable description and unique error code.

Parameters:nodes (str) – [required] List of node IPs for the nodes that will be added to the cluster.
nodes = <type 'str[]'>
class solidfire.models.CheckProposedResult(proposed_cluster_valid, proposed_cluster_errors)[source]

Bases: solidfire.common.model.DataObject

Parameters:
  • proposed_cluster_valid (bool) – [required] True if there were no errors found with the proposed cluster, false otherwise
  • proposed_cluster_errors (ProposedClusterError) – [required] The errors associated with the proposed cluster.
proposed_cluster_errors = <class 'solidfire.models.ProposedClusterError[]'>
proposed_cluster_valid = <type 'bool'>
class solidfire.models.ClearClusterFaultsRequest(fault_types=None)[source]

Bases: solidfire.common.model.DataObject

You can use the ClearClusterFaults method to clear information about both current and previously detected faults. Both resolved and unresolved faults can be cleared.

Parameters:fault_types (str) – Determines the types of faults cleared. Possible values are: current: Faults that are currently detected and have not been resolved. resolved: (Default) Faults that were previously detected and resolved. all: Both current and resolved faults are cleared. The fault status can be determined by the resolved field of the fault object.
fault_types = <type 'str'>
class solidfire.models.ClearClusterFaultsResult[source]

Bases: solidfire.common.model.DataObject

class solidfire.models.CloneMultipleVolumeParams(volume_id, access=None, name=None, new_account_id=None, new_size=None, attributes=None)[source]

Bases: solidfire.common.model.DataObject

Parameters:
  • volume_id (int) – [required] Required parameter for “volumes” array: volumeID.
  • access (str) – Access settings for the new volume. readOnly: Only read operations are allowed. readWrite: Reads and writes are allowed. locked: No reads or writes are allowed. replicationTarget: Identify a volume as the target volume for a paired set of volumes. If the volume is not paired, the access status is locked. If unspecified, the access settings of the clone will be the same as the source.
  • name (str) – New name for the clone.
  • new_account_id (int) – Account ID for the new volume.
  • new_size (int) – New size Total size of the volume, in bytes. Size is rounded up to the nearest 1MB size.
  • attributes (dict) – List of Name/Value pairs in JSON object format.
access = <type 'str'>
attributes = <type 'dict'>
name = <type 'str'>
new_account_id = <type 'int'>
new_size = <type 'int'>
volume_id = <type 'int'>
class solidfire.models.CloneMultipleVolumesRequest(volumes, access=None, group_snapshot_id=None, new_account_id=None)[source]

Bases: solidfire.common.model.DataObject

CloneMultipleVolumes enables you to create a clone of a group of specified volumes. You can assign a consistent set of characteristics to a group of multiple volumes when they are cloned together. Before using groupSnapshotID to clone the volumes in a group snapshot, you must create the group snapshot by using the CreateGroupSnapshot API method or the Element OS Web UI. Using groupSnapshotID is optional when cloning multiple volumes. Note: Cloning multiple volumes is allowed if cluster fullness is at stage 2 or 3. Clones are not created when cluster fullness is at stage 4 or 5.

Parameters:
  • volumes (CloneMultipleVolumeParams) – [required] Unique ID for each volume to include in the clone. If optional parameters are not specified, the values are inherited from the source volumes. Required parameter for “volumes” array: volumeID Optional parameters for “volumes” array: access: Can be one of readOnly, readWrite, locked, or replicationTarget attributes: List of name-value pairs in JSON object format. name: New name for the clone. newAccountID: Account ID for the new volumes. newSize: New size Total size of the volume, in bytes. Size is rounded up to the nearest 1MB.
  • access (str) – New default access method for the new volumes if not overridden by information passed in the volume’s array.
  • group_snapshot_id (int) – ID of the group snapshot to use as a basis for the clone.
  • new_account_id (int) – New account ID for the volumes if not overridden by information passed in the volumes array.
access = <type 'str'>
group_snapshot_id = <type 'int'>
new_account_id = <type 'int'>
volumes = <class 'solidfire.models.CloneMultipleVolumeParams[]'>
class solidfire.models.CloneMultipleVolumesResult(async_handle, group_clone_id, members)[source]

Bases: solidfire.common.model.DataObject

Parameters:
  • async_handle (int) – [required] A value returned from an asynchronous method call.
  • group_clone_id (int) – [required] Unique ID of the new group clone.
  • members (GroupCloneVolumeMember) – [required] List of volumeIDs for the source and destination volume pairs.
async_handle = <type 'int'>
group_clone_id = <type 'int'>
members = <class 'solidfire.models.GroupCloneVolumeMember[]'>
class solidfire.models.CloneVolumeRequest(volume_id, name, new_account_id=None, new_size=None, access=None, snapshot_id=None, attributes=None, enable512e=None, enable_snap_mirror_replication=None)[source]

Bases: solidfire.common.model.DataObject

CloneVolume enables you to create a copy of a volume. This method is asynchronous and might take a variable amount of time to complete. The cloning process begins immediately when you make the CloneVolume request and is representative of the state of the volume when the API method is issued. You can use the GetAsyncResult method to determine when the cloning process is complete and the new volume is available for connections. You can use ListSyncJobs to see the progress of creating the clone. Note: The initial attributes and QoS settings for the volume are inherited from the volume being cloned. You can change these settings with ModifyVolume. Note: Cloned volumes do not inherit volume access group memberships from the source volume.

Parameters:
  • volume_id (int) – [required] VolumeID for the volume to be cloned.
  • name (str) – [required] The name of the new cloned volume. Must be 1 to 64 characters in length.
  • new_account_id (int) – AccountID for the owner of the new volume. If unspecified, the accountID of the owner of the volume being cloned is used.
  • new_size (int) – New size of the volume, in bytes. Must be greater or less than the size of the volume being cloned. If unspecified, the volume size is not changed. Size is rounded to the nearest 1MB.
  • access (VolumeAccess) – Specifies the level of access allowed for the new volume. If unspecified, the level of access of the volume being cloned is used. If replicationTarget is is passed and the volume is not paired, the access gets set to locked.
  • snapshot_id (int) – ID of the snapshot that is used as the source of the clone. If no ID is provided, the current active volume is used.
  • attributes (dict) – List of name-value pairs in JSON object format.
  • enable512e (bool) – Specifies whether the new volume should use 512-byte sector emulation. If unspecified, the setting of the volume being cloned is used.
  • enable_snap_mirror_replication (bool) – Specifies whether SnapMirror replication is enabled or not. Defaults to false.
access = <class 'solidfire.models.VolumeAccess'>
attributes = <type 'dict'>
enable512e = <type 'bool'>
enable_snap_mirror_replication = <type 'bool'>
name = <type 'str'>
new_account_id = <type 'int'>
new_size = <type 'int'>
snapshot_id = <type 'int'>
volume_id = <type 'int'>
class solidfire.models.CloneVolumeResult(clone_id, volume_id, curve, async_handle, volume=None)[source]

Bases: solidfire.common.model.DataObject

Parameters:
  • volume (Volume) – The resulting volume
  • clone_id (int) – [required] The ID of the newly-created clone.
  • volume_id (int) – [required] The volume ID of the newly-created clone.
  • curve (dict) – [required] The curve is a set of key-value pairs. The keys are I/O sizes in bytes. The values represent the cost of performing an IOP at a specific I/O size. The curve is calculated relative to a 4096 byte operation set at 100 IOPS.
  • async_handle (int) – [required] Handle value used to track the progress of the clone.
async_handle = <type 'int'>
clone_id = <type 'int'>
curve = <type 'dict'>
volume = <class 'solidfire.models.Volume'>
volume_id = <type 'int'>
class solidfire.models.ClusterAdmin(auth_method, access, cluster_admin_id, username, attributes=None)[source]

Bases: solidfire.common.model.DataObject

Parameters:
  • auth_method (str) – [required] Method in which the cluster admin can be authenticated.
  • access (str) – [required] Controls which methods this cluster admin can use. For more details, see Access Control in the Element API Reference Guide.
  • cluster_admin_id (int) – [required] Unique identifier for the cluster admin
  • username (str) – [required] Username, LDAP DN, or SAML Attribute for the cluster admin.
  • attributes (dict) – List of Name/Value pairs in JSON object format.
access = <type 'str[]'>
attributes = <type 'dict'>
auth_method = <type 'str'>
cluster_admin_id = <type 'int'>
username = <type 'str'>
class solidfire.models.ClusterCapacity(active_block_space, active_sessions, average_iops, cluster_recent_iosize, current_iops, max_iops, max_over_provisionable_space, max_provisioned_space, max_used_metadata_space, max_used_space, non_zero_blocks, peak_active_sessions, peak_iops, provisioned_space, snapshot_non_zero_blocks, timestamp, total_ops, unique_blocks, unique_blocks_used_space, used_metadata_space, used_metadata_space_in_snapshots, used_space, zero_blocks)[source]

Bases: solidfire.common.model.DataObject

High level capacity measurements for the entire cluster.

Parameters:
  • active_block_space (int) – [required] The amount of space on the block drives. This includes additional information such as metadata entries and space which can be cleaned up.
  • active_sessions (int) – [required] Number of active iSCSI sessions communicating with the cluster
  • average_iops (int) – [required] Average IPS for the cluster since midnight Coordinated Universal Time (UTC).
  • cluster_recent_iosize (int) – [required] The average size of IOPS to all volumes in the cluster.
  • current_iops (int) – [required] Average IOPS for all volumes in the cluster over the last 5 seconds.
  • max_iops (int) – [required] Estimated maximum IOPS capability of the current cluster.
  • max_over_provisionable_space (int) – [required] The maximum amount of provisionable space. This is a computed value. You cannot create new volumes if the current provisioned space plus the new volume size would exceed this number: maxOverProvisionableSpace = maxProvisionedSpace * GetClusterFull
  • max_provisioned_space (int) – [required] The total amount of provisionable space if all volumes are 100% filled (no thin provisioned metadata).
  • max_used_metadata_space (int) – [required] The amount of bytes on volume drives used to store metadata.
  • max_used_space (int) – [required] The total amount of space on all active block drives.
  • non_zero_blocks (int) – [required] Total number of 4KiB blocks with data after the last garbage collection operation has completed.
  • peak_active_sessions (int) – [required] Peak number of iSCSI connections since midnight UTC.
  • peak_iops (int) – [required] The highest value for currentIOPS since midnight UTC.
  • provisioned_space (int) – [required] Total amount of space provisioned in all volumes on the cluster.
  • snapshot_non_zero_blocks (int) – [required] Total number of 4KiB blocks in snapshots with data.
  • timestamp (str) – [required] The date and time this cluster capacity sample was taken.
  • total_ops (int) – [required] The total number of I/O operations performed throughout the lifetime of the cluster
  • unique_blocks (int) – [required] The total number of blocks stored on the block drives. The value includes replicated blocks.
  • unique_blocks_used_space (int) – [required] The total amount of data the uniqueBlocks take up on the block drives. This number is always consistent with the uniqueBlocks value.
  • used_metadata_space (int) – [required] The total amount of bytes on volume drives used to store metadata
  • used_metadata_space_in_snapshots (int) – [required] The amount of bytes on volume drives used for storing unique data in snapshots. This number provides an estimate of how much metadata space would be regained by deleting all snapshots on the system.
  • used_space (int) – [required] Total amount of space used by all block drives in the system.
  • zero_blocks (int) – [required] Total number of 4KiB blocks without data after the last round of garabage collection operation has completed.
active_block_space = <type 'int'>
active_sessions = <type 'int'>
average_iops = <type 'int'>
cluster_recent_iosize = <type 'int'>
current_iops = <type 'int'>
max_iops = <type 'int'>
max_over_provisionable_space = <type 'int'>
max_provisioned_space = <type 'int'>
max_used_metadata_space = <type 'int'>
max_used_space = <type 'int'>
non_zero_blocks = <type 'int'>
peak_active_sessions = <type 'int'>
peak_iops = <type 'int'>
provisioned_space = <type 'int'>
snapshot_non_zero_blocks = <type 'int'>
timestamp = <type 'str'>
total_ops = <type 'int'>
unique_blocks = <type 'int'>
unique_blocks_used_space = <type 'int'>
used_metadata_space = <type 'int'>
used_metadata_space_in_snapshots = <type 'int'>
used_space = <type 'int'>
zero_blocks = <type 'int'>
class solidfire.models.ClusterConfig(cipi=None, cluster=None, ensemble=None, mipi=None, name=None, node_id=None, pending_node_id=None, role=None, sipi=None, state=None, encryption_capable=None, fips_drive_configuration=None, has_local_admin=None, version=None)[source]

Bases: solidfire.common.model.DataObject

Cluster Config object returns information the node uses to communicate with the cluster.

Parameters:
  • cipi (str) – Network interface used for cluster communication.
  • cluster (str) – Unique cluster name.
  • ensemble (str) – Nodes that are participating in the cluster.
  • mipi (str) – Network interface used for node management.
  • name (str) – Unique cluster name.
  • node_id (int) –
  • pending_node_id (int) –
  • role (str) – Identifies the role of the node
  • sipi (str) – Network interface used for storage.
  • state (str) –
  • encryption_capable (bool) – This field indicates whether the node supports encryption.
  • fips_drive_configuration (bool) – This field indicates whether the node supports FIPS 140-2 certified drives.
  • has_local_admin (bool) –
  • version (str) –
cipi = <type 'str'>
cluster = <type 'str'>
encryption_capable = <type 'bool'>
ensemble = <type 'str[]'>
fips_drive_configuration = <type 'bool'>
has_local_admin = <type 'bool'>
mipi = <type 'str'>
name = <type 'str'>
node_id = <type 'int'>
pending_node_id = <type 'int'>
role = <type 'str'>
sipi = <type 'str'>
state = <type 'str'>
version = <type 'str'>
class solidfire.models.ClusterFaultInfo(severity, type, code, details, node_hardware_fault_id, node_id, service_id, drive_id, resolved, cluster_fault_id, date, resolved_date, drive_ids=None, network_interface=None, data=None, external_source=None)[source]

Bases: solidfire.common.model.DataObject

Parameters:
  • drive_ids (int) –
  • network_interface (str) –
  • severity (str) – [required]
  • type (str) – [required]
  • code (str) – [required]
  • details (str) – [required]
  • node_hardware_fault_id (int) – [required]
  • node_id (int) – [required]
  • service_id (int) – [required]
  • drive_id (int) – [required]
  • resolved (bool) – [required]
  • cluster_fault_id (int) – [required]
  • date (str) – [required]
  • resolved_date (str) – [required]
  • data (dict) –
  • external_source (str) –
cluster_fault_id = <type 'int'>
code = <type 'str'>
data = <type 'dict'>
date = <type 'str'>
details = <type 'str'>
drive_id = <type 'int'>
drive_ids = <type 'int[]'>
external_source = <type 'str'>
network_interface = <type 'str'>
node_hardware_fault_id = <type 'int'>
node_id = <type 'int'>
resolved = <type 'bool'>
resolved_date = <type 'str'>
service_id = <type 'int'>
severity = <type 'str'>
type = <type 'str'>
class solidfire.models.ClusterHardwareInfo(drives, nodes)[source]

Bases: solidfire.common.model.DataObject

Parameters:
  • drives (dict) – [required]
  • nodes (dict) – [required]
drives = <type 'dict'>
nodes = <type 'dict'>
class solidfire.models.ClusterInfo(encryption_at_rest_state, software_encryption_at_rest_state, ensemble, mvip, mvip_node_id, name, rep_count, supported_protection_schemes, enabled_protection_schemes, default_protection_scheme, svip, svip_node_id, unique_id, uuid, attributes, mvip_interface=None, mvip_vlan_tag=None, svip_interface=None, svip_vlan_tag=None)[source]

Bases: solidfire.common.model.DataObject

Cluster Info object returns information the node uses to communicate with the cluster.

Parameters:
  • mvip_interface (str) –
  • mvip_vlan_tag (str) –
  • svip_interface (str) –
  • svip_vlan_tag (str) –
  • encryption_at_rest_state (str) – [required] Encryption at rest state.
  • software_encryption_at_rest_state (str) – [required] Software-based encryption-at-rest state.
  • ensemble (str) – [required] Array of Node IP addresses that are participating in the cluster.
  • mvip (str) – [required] Management network interface.
  • mvip_node_id (int) – [required] Node holding the master MVIP address
  • name (str) – [required] Unique cluster name.
  • rep_count (int) – [required] Number of replicas of each piece of data to store in the cluster.
  • supported_protection_schemes (ProtectionScheme) – [required] A list of all of the protection schemes that are supported on this cluster.
  • enabled_protection_schemes (ProtectionScheme) – [required] A list of all of the protection schemes that have been enabled on this cluster.
  • default_protection_scheme (ProtectionScheme) – [required] If a protection scheme is not provided to the CreateVolume call, this protection scheme will be used for the new volume. This protection scheme must always be in the set of enabled protection schemes.
  • svip (str) – [required] Storage virtual IP
  • svip_node_id (int) – [required] Node holding the master SVIP address.
  • unique_id (str) – [required] Unique ID for the cluster.
  • uuid (UUID) – [required]
  • attributes (dict) – [required] List of Name/Value pairs in JSON object format.
attributes = <type 'dict'>
default_protection_scheme = <class 'solidfire.models.ProtectionScheme'>
enabled_protection_schemes = <class 'solidfire.models.ProtectionScheme[]'>
encryption_at_rest_state = <type 'str'>
ensemble = <type 'str[]'>
mvip = <type 'str'>
mvip_interface = <type 'str'>
mvip_node_id = <type 'int'>
mvip_vlan_tag = <type 'str'>
name = <type 'str'>
rep_count = <type 'int'>
software_encryption_at_rest_state = <type 'str'>
supported_protection_schemes = <class 'solidfire.models.ProtectionScheme[]'>
svip = <type 'str'>
svip_interface = <type 'str'>
svip_node_id = <type 'int'>
svip_vlan_tag = <type 'str'>
unique_id = <type 'str'>
uuid = <class 'uuid.UUID'>
class solidfire.models.ClusterInterfacePreference(name, value)[source]

Bases: solidfire.common.model.DataObject

Parameters:
  • name (str) – [required] Name of the cluster interface preference
  • value (str) – [required] Value of the cluster interface preference
name = <type 'str'>
value = <type 'str'>
class solidfire.models.ClusterStats(cluster_utilization, client_queue_depth, normalized_iops, read_bytes, read_latency_usec_total, read_ops, services_count, services_total, timestamp, write_bytes, write_latency_usec_total, write_ops, actual_iops=None, average_iopsize=None, latency_usec=None, read_bytes_last_sample=None, read_latency_usec=None, read_ops_last_sample=None, sample_period_msec=None, unaligned_reads=None, unaligned_writes=None, write_bytes_last_sample=None, write_latency_usec=None, write_ops_last_sample=None)[source]

Bases: solidfire.common.model.DataObject

Parameters:
  • cluster_utilization (float) – [required] The amount of cluster capacity being utilized.
  • client_queue_depth (int) – [required]
  • normalized_iops (int) – [required]
  • read_bytes (int) – [required] Total bytes read by clients.
  • read_latency_usec_total (int) – [required]
  • read_ops (int) – [required] Total read operations.
  • services_count (int) – [required] Services count
  • services_total (int) – [required] Total services.
  • timestamp (str) – [required] Current time in UTC format. ISO 8601 date string.
  • write_bytes (int) – [required] Total bytes written by clients.
  • write_latency_usec_total (int) – [required]
  • write_ops (int) – [required] Total write operations.
  • actual_iops (int) –
  • average_iopsize (int) –
  • latency_usec (int) –
  • read_bytes_last_sample (int) –
  • read_latency_usec (int) –
  • read_ops_last_sample (int) –
  • sample_period_msec (int) –
  • unaligned_reads (int) –
  • unaligned_writes (int) –
  • write_bytes_last_sample (int) –
  • write_latency_usec (int) –
  • write_ops_last_sample (int) –
actual_iops = <type 'int'>
average_iopsize = <type 'int'>
client_queue_depth = <type 'int'>
cluster_utilization = <type 'float'>
latency_usec = <type 'int'>
normalized_iops = <type 'int'>
read_bytes = <type 'int'>
read_bytes_last_sample = <type 'int'>
read_latency_usec = <type 'int'>
read_latency_usec_total = <type 'int'>
read_ops = <type 'int'>
read_ops_last_sample = <type 'int'>
sample_period_msec = <type 'int'>
services_count = <type 'int'>
services_total = <type 'int'>
timestamp = <type 'str'>
unaligned_reads = <type 'int'>
unaligned_writes = <type 'int'>
write_bytes = <type 'int'>
write_bytes_last_sample = <type 'int'>
write_latency_usec = <type 'int'>
write_latency_usec_total = <type 'int'>
write_ops = <type 'int'>
write_ops_last_sample = <type 'int'>
class solidfire.models.ClusterVersionInfo(node_id, node_version, node_internal_revision)[source]

Bases: solidfire.common.model.DataObject

Version information for a node in the cluster.

Parameters:
  • node_id (int) – [required]
  • node_version (str) – [required]
  • node_internal_revision (str) – [required]
node_id = <type 'int'>
node_internal_revision = <type 'str'>
node_version = <type 'str'>
class solidfire.models.CompleteClusterPairingRequest(cluster_pairing_key)[source]

Bases: solidfire.common.model.DataObject

You can use the CompleteClusterPairing method with the encoded key received from the StartClusterPairing method to complete the cluster pairing process. The CompleteClusterPairing method is the second step in the cluster pairing process.

Parameters:cluster_pairing_key (str) – [required] A string of characters that is returned from the “StartClusterPairing” API method.
cluster_pairing_key = <type 'str'>
class solidfire.models.CompleteClusterPairingResult(cluster_pair_id)[source]

Bases: solidfire.common.model.DataObject

Parameters:cluster_pair_id (int) – [required] Unique identifier for the cluster pair.
cluster_pair_id = <type 'int'>
class solidfire.models.CompleteVolumePairingRequest(volume_pairing_key, volume_id)[source]

Bases: solidfire.common.model.DataObject

You can use the CompleteVolumePairing method to complete the pairing of two volumes.

Parameters:
  • volume_pairing_key (str) – [required] The key returned from the StartVolumePairing method.
  • volume_id (int) – [required] The ID of the volume on which to complete the pairing process.
volume_id = <type 'int'>
volume_pairing_key = <type 'str'>
class solidfire.models.CompleteVolumePairingResult[source]

Bases: solidfire.common.model.DataObject

class solidfire.models.Config(cluster, network)[source]

Bases: solidfire.common.model.DataObject

Parameters:
cluster = <class 'solidfire.models.ClusterConfig'>
network = <class 'solidfire.models.Network'>
class solidfire.models.ConfigParams(cluster, network)[source]

Bases: solidfire.common.model.DataObject

Parameters:
cluster = <class 'solidfire.models.ClusterConfig'>
network = <class 'solidfire.models.NetworkParams'>
class solidfire.models.ControlPowerRequest(action, force, wakeup_delay=None)[source]

Bases: solidfire.common.model.DataObject

ControlPower can be used to reboot or halt a node.

Parameters:
  • action (str) – [required] The action to take (Must be either Halt or Restart).
  • wakeup_delay (str) – The delay in seconds to wait before powering on. This is only usable when action=Halt.
  • force (bool) – [required] Required for the command to succeed.
action = <type 'str'>
force = <type 'bool'>
wakeup_delay = <type 'str'>
class solidfire.models.ControlPowerResult(details, duration, result)[source]

Bases: solidfire.common.model.DataObject

Parameters:
  • details (dict) – [required] The detailed results from ControlPower. There is currently not any detailed information.
  • duration (str) – [required] The amount of time required to for ControlPower to complete in the format HH:MM:SS.ssssss
  • result (str) – [required] Whether ControlPower passed or failed.
details = <type 'dict'>
duration = <type 'str'>
result = <type 'str'>
class solidfire.models.CopyVolumeRequest(volume_id, dst_volume_id, snapshot_id=None)[source]

Bases: solidfire.common.model.DataObject

CopyVolume enables you to overwrite the data contents of an existing volume with the data contents of another volume (or snapshot). Attributes of the destination volume such as IQN, QoS settings, size, account, and volume access group membership are not changed. The destination volume must already exist and must be the same size as the source volume. NetApp strongly recommends that clients unmount the destination volume before the CopyVolume operation begins. If the destination volume is modified during the copy operation, the changes will be lost. This method is asynchronous and may take a variable amount of time to complete. You can use the GetAsyncResult method to determine when the process has finished, and ListSyncJobs to see the progress of the copy.

Parameters:
  • volume_id (int) – [required] VolumeID of the volume to be read from.
  • dst_volume_id (int) – [required] VolumeID of the volume to be overwritten.
  • snapshot_id (int) – ID of the snapshot that is used as the source of the clone. If no ID is provided, the current active volume is used.
dst_volume_id = <type 'int'>
snapshot_id = <type 'int'>
volume_id = <type 'int'>
class solidfire.models.CopyVolumeResult(clone_id, async_handle)[source]

Bases: solidfire.common.model.DataObject

Parameters:
  • clone_id (int) – [required]
  • async_handle (int) – [required] Handle value used to track the progress of the volume copy.
async_handle = <type 'int'>
clone_id = <type 'int'>
class solidfire.models.CreateBackupTargetRequest(name, attributes)[source]

Bases: solidfire.common.model.DataObject

CreateBackupTarget enables you to create and store backup target information so that you do not need to re-enter it each time a backup is created.

Parameters:
  • name (str) – [required] The name of the backup target.
  • attributes (dict) – [required] List of name-value pairs in JSON object format.
attributes = <type 'dict'>
name = <type 'str'>
class solidfire.models.CreateBackupTargetResult(backup_target_id)[source]

Bases: solidfire.common.model.DataObject

Parameters:backup_target_id (int) – [required] Unique identifier assigned to the backup target.
backup_target_id = <type 'int'>
class solidfire.models.CreateClusterInterfacePreferenceRequest(name, value)[source]

Bases: solidfire.common.model.DataObject

Creates a new cluster preference and stores it on the storage cluster. The ClusterInterfacePreference related APIs can be used by internal interfaces to the storage cluster such as HCI and UI to store arbitrary information in the cluster. Since the API calls in the UI are visible to customers, these APIs are made public.

Parameters:
  • name (str) – [required] Name of the cluster interface preference.
  • value (str) – [required] Value of the cluster interface preference.
name = <type 'str'>
value = <type 'str'>
class solidfire.models.CreateClusterInterfacePreferenceResult[source]

Bases: solidfire.common.model.DataObject

class solidfire.models.CreateClusterRequest(mvip, svip, username, password, nodes, accept_eula=None, serial_number=None, order_number=None, attributes=None, enable_software_encryption_at_rest=None)[source]

Bases: solidfire.common.model.DataObject

The CreateCluster method enables you to initialize the node in a cluster that has ownership of the “mvip” and “svip” addresses. Each new cluster is initialized using the management IP (MIP) of the first node in the cluster. This method also automatically adds all the nodes being configured into the cluster. You only need to use this method once each time a new cluster is initialized. Note: You need to log in to the node that is used as the master node for the cluster. After you log in, run the GetBootstrapConfig method on the node to get the IP addresses for the rest of the nodes that you want to include in the cluster. Then, run the CreateCluster method.

Parameters:
  • accept_eula (bool) – Required to indicate your acceptance of the End User License Agreement when creating this cluster. To accept the EULA, set this parameter to true.
  • serial_number (str) – Nine-digit alphanumeric Serial Number. May be required on software-based platforms.
  • order_number (str) – Alphanumeric sales order number. May be required on software-based platforms.
  • mvip (str) – [required] Floating (virtual) IP address for the cluster on the management network.
  • svip (str) – [required] Floating (virtual) IP address for the cluster on the storage (iSCSI) network.
  • username (str) – [required] Username for the cluster admin.
  • password (str) – [required] Initial password for the cluster admin account.
  • nodes (str) – [required] CIP/SIP addresses of the initial set of nodes making up the cluster. This node’s IP must be in the list.
  • attributes (dict) – List of name-value pairs in JSON object format.
  • enable_software_encryption_at_rest (bool) – Enable this flag to use software-based encryption-at-rest. Defaults to true on SolidFire software-only clusters. Defaults to false on all other clusters.
accept_eula = <type 'bool'>
attributes = <type 'dict'>
enable_software_encryption_at_rest = <type 'bool'>
mvip = <type 'str'>
nodes = <type 'str[]'>
order_number = <type 'str'>
password = <type 'str'>
serial_number = <type 'str'>
svip = <type 'str'>
username = <type 'str'>
class solidfire.models.CreateClusterResult[source]

Bases: solidfire.common.model.DataObject

class solidfire.models.CreateGroupSnapshotRequest(volumes, name=None, enable_remote_replication=None, retention=None, attributes=None, snap_mirror_label=None)[source]

Bases: solidfire.common.model.DataObject

CreateGroupSnapshot enables you to create a point-in-time copy of a group of volumes. You can use this snapshot later as a backup or rollback to ensure the data on the group of volumes is consistent for the point in time that you created the snapshot. Note: Creating a group snapshot is allowed if cluster fullness is at stage 2 or 3. Snapshots are not created when cluster fullness is at stage 4 or 5.

Parameters:
  • volumes (int) – [required] Unique ID of the volume image from which to copy.
  • name (str) – Name for the group snapshot. If unspecified, the date and time the group snapshot was taken is used.
  • enable_remote_replication (bool) – Replicates the snapshot created to remote storage. Possible values are: true: The snapshot is replicated to remote storage. false: Default. The snapshot is not replicated.
  • retention (str) – Specifies the amount of time for which the snapshots are retained. The format is HH:mm:ss.
  • attributes (dict) – List of name-value pairs in JSON object format.
  • snap_mirror_label (str) – Label used by SnapMirror software to specify snapshot retention policy on SnapMirror endpoint.
attributes = <type 'dict'>
enable_remote_replication = <type 'bool'>
name = <type 'str'>
retention = <type 'str'>
snap_mirror_label = <type 'str'>
volumes = <type 'int[]'>
class solidfire.models.CreateGroupSnapshotResult(group_snapshot, group_snapshot_id, members)[source]

Bases: solidfire.common.model.DataObject

Parameters:
  • group_snapshot (GroupSnapshot) – [required]
  • group_snapshot_id (int) – [required] Unique ID of the new group snapshot.
  • members (GroupSnapshotMembers) – [required] List of checksum, volumeIDs and snapshotIDs for each member of the group.
group_snapshot = <class 'solidfire.models.GroupSnapshot'>
group_snapshot_id = <type 'int'>
members = <class 'solidfire.models.GroupSnapshotMembers[]'>
class solidfire.models.CreateIdpConfigurationRequest(idp_name, idp_metadata)[source]

Bases: solidfire.common.model.DataObject

Create a potential trust relationship for authentication using a third party Identity Provider (IdP) for the cluster. A SAML Service Provider certificate is required for IdP communication, which will be generated as necessary.

Parameters:
  • idp_name (str) – [required] Name used to identify an IdP provider for SAML 2.0 single sign-on.
  • idp_metadata (str) – [required] IdP Metadata to store.
idp_metadata = <type 'str'>
idp_name = <type 'str'>
class solidfire.models.CreateIdpConfigurationResult(idp_config_info)[source]

Bases: solidfire.common.model.DataObject

Parameters:idp_config_info (IdpConfigInfo) – [required] Information around the third party Identity Provider (IdP) configuration.
idp_config_info = <class 'solidfire.models.IdpConfigInfo'>
class solidfire.models.CreateInitiator(name, alias=None, volume_access_group_id=None, attributes=None, require_chap=None, chap_username=None, initiator_secret=None, target_secret=None, virtual_network_ids=None)[source]

Bases: solidfire.common.model.DataObject

Object containing characteristics of each new initiator to be created.

Parameters:
  • name (str) – [required] The name of the initiator (IQN or WWPN) to create.
  • alias (str) – The friendly name to assign to this initiator.
  • volume_access_group_id (int) – The ID of the volume access group to which this newly created initiator will be added.
  • attributes (dict) – A set of JSON attributes assigned to this initiator. (JSON Object)
  • require_chap (bool) – “requireChap” determines if the initiator is required to use CHAP during session login. CHAP is optional if “requireChap” is false.
  • chap_username (str) – The CHAP username for this initiator. Defaults to the initiator name (IQN) if not specified during creation and “requireChap” is true.
  • initiator_secret (CHAPSecret) – The CHAP secret used for authentication of the initiator. Defaults to a randomly generated secret if not specified during creation and “requireChap” is true.
  • target_secret (CHAPSecret) – The CHAP secret used for authentication of the target. Defaults to a randomly generated secret if not specified during creation and “requireChap” is true.
  • virtual_network_ids (int) – The list of virtual network identifiers associated with this initiator. If one or more are defined, this initiator will only be able to login to the specified virtual networks. If no virtual networks are defined this initiator can login to all networks.
alias = <type 'str'>
attributes = <type 'dict'>
chap_username = <type 'str'>
initiator_secret = <class 'solidfire.models.CHAPSecret'>
name = <type 'str'>
require_chap = <type 'bool'>
target_secret = <class 'solidfire.models.CHAPSecret'>
virtual_network_ids = <type 'int[]'>
volume_access_group_id = <type 'int'>
class solidfire.models.CreateInitiatorsRequest(initiators)[source]

Bases: solidfire.common.model.DataObject

CreateInitiators enables you to create multiple new initiator IQNs or World Wide Port Names (WWPNs) and optionally assign them aliases and attributes. When you use CreateInitiators to create new initiators, you can also add them to volume access groups. If CreateInitiators fails to create one of the initiators provided in the parameter, the method returns an error and does not create any initiators (no partial completion is possible).

Parameters:initiators (CreateInitiator) – [required] A list of objects containing characteristics of each new initiator.
initiators = <class 'solidfire.models.CreateInitiator[]'>
class solidfire.models.CreateInitiatorsResult(initiators)[source]

Bases: solidfire.common.model.DataObject

Parameters:initiators (Initiator) – [required] List of objects containing details about the newly created initiators.
initiators = <class 'solidfire.models.Initiator[]'>
class solidfire.models.CreateKeyProviderKmipRequest(key_provider_name)[source]

Bases: solidfire.common.model.DataObject

Creates a KMIP (Key Management Interoperability Protocol) Key Provider with the specified name. A Key Provider defines a mechanism and location to retrieve authentication keys. A KMIP Key Provider represents a collection of one or more KMIP Key Servers. A newly created KMIP Key Provider will not have any KMIP Key Servers assigned to it. To create a KMIP Key Server see CreateKeyServerKmip and to assign it to a provider created via this method see AddKeyServerToProviderKmip.

Parameters:key_provider_name (str) – [required] The name to associate with the created KMIP Key Provider. This name is only used for display purposes and does not need to be unique.
key_provider_name = <type 'str'>
class solidfire.models.CreateKeyProviderKmipResult(kmip_key_provider)[source]

Bases: solidfire.common.model.DataObject

Parameters:kmip_key_provider (KeyProviderKmip) – [required] The KMIP (Key Management Interoperability Protocol) Key Provider which has been created.
kmip_key_provider = <class 'solidfire.models.KeyProviderKmip'>
class solidfire.models.CreateKeyServerKmipRequest(kmip_ca_certificate, kmip_client_certificate, kmip_key_server_hostnames, kmip_key_server_name, kmip_key_server_port=None)[source]

Bases: solidfire.common.model.DataObject

Creates a KMIP (Key Management Interoperability Protocol) Key Server with the specified attributes. The server will not be contacted as part of this operation so it need not exist or be configured prior. For clustered Key Server configurations, the hostnames or IP Addresses, of all server nodes, must be provided in the kmipKeyServerHostnames parameter.

Parameters:
  • kmip_ca_certificate (str) – [required] The public key certificate of the external key server’s root CA. This will be used to verify the certificate presented by external key server in the TLS communication. For key server clusters where individual servers use different CAs, provide a concatenated string containing the root certificates of all the CAs.
  • kmip_client_certificate (str) – [required] A PEM format Base64 encoded PKCS#10 X.509 certificate used by the Solidfire KMIP client.
  • kmip_key_server_hostnames (str) – [required] Array of the hostnames or IP addresses associated with this KMIP Key Server. Multiple hostnames or IP addresses must only be provided if the key servers are in a clustered configuration.
  • kmip_key_server_name (str) – [required] The name of the KMIP Key Server. This name is only used for display purposes and does not need to be unique.
  • kmip_key_server_port (int) – The port number associated with this KMIP Key Server (typically 5696).
kmip_ca_certificate = <type 'str'>
kmip_client_certificate = <type 'str'>
kmip_key_server_hostnames = <type 'str[]'>
kmip_key_server_name = <type 'str'>
kmip_key_server_port = <type 'int'>
class solidfire.models.CreateKeyServerKmipResult(kmip_key_server)[source]

Bases: solidfire.common.model.DataObject

Parameters:kmip_key_server (KeyServerKmip) – [required] The KMIP (Key Management Interoperability Protocol) Key Server which has been created.
kmip_key_server = <class 'solidfire.models.KeyServerKmip'>
class solidfire.models.CreatePublicPrivateKeyPairRequest(common_name=None, organization=None, organizational_unit=None, locality=None, state=None, country=None, email_address=None)[source]

Bases: solidfire.common.model.DataObject

Creates SSL public and private keys. These keys can be used to generate Certificate Sign Requests. There can be only one key pair in use for the cluster. To replace the existing keys, make sure that they are not being used by any providers before invoking this API.

Parameters:
  • common_name (str) – This is the X.509 distinguished name Common Name field (CN).
  • organization (str) – This is the X.509 distinguished name Organization Name field (O).
  • organizational_unit (str) – This is the X.509 distinguished name Organizational Unit Name field (OU).
  • locality (str) – This is the X.509 distinguished name Locality Name field (L).
  • state (str) – This is the X.509 distinguished name State or Province Name field (ST or SP or S).
  • country (str) – This is the X.509 distinguished name Country field (C).
  • email_address (str) – This is the X.509 distinguished name Email Address field (MAIL).
common_name = <type 'str'>
country = <type 'str'>
email_address = <type 'str'>
locality = <type 'str'>
organization = <type 'str'>
organizational_unit = <type 'str'>
state = <type 'str'>
class solidfire.models.CreatePublicPrivateKeyPairResult[source]

Bases: solidfire.common.model.DataObject

There is no additional data returned as the creation of keys is considered successful as long as there is no error.

class solidfire.models.CreateQoSPolicyRequest(name, qos)[source]

Bases: solidfire.common.model.DataObject

You can use the CreateQoSPolicy method to create a QoSPolicy object that you can later apply to a volume upon creation or modification. A QoS policy has a unique ID, a name, and QoS settings.

Parameters:
  • name (str) – [required] The name of the QoS policy; for example, gold, platinum, or silver.
  • qos (QoS) – [required] The QoS settings that this policy represents.
name = <type 'str'>
qos = <class 'solidfire.models.QoS'>
class solidfire.models.CreateQoSPolicyResult(qos_policy)[source]

Bases: solidfire.common.model.DataObject

Parameters:qos_policy (QoSPolicy) – [required] The newly created QoSPolicy object.
qos_policy = <class 'solidfire.models.QoSPolicy'>
class solidfire.models.CreateScheduleRequest(schedule)[source]

Bases: solidfire.common.model.DataObject

CreateSchedule enables you to schedule an automatic snapshot of a volume at a defined interval. You can use the created snapshot later as a backup or rollback to ensure the data on a volume or group of volumes is consistent for the point in time in which the snapshot was created. If you schedule a snapshot to run at a time period that is not divisible by 5 minutes, the snapshot runs at the next time period that is divisible by 5 minutes. For example, if you schedule a snapshot to run at 12:42:00 UTC, it runs at 12:45:00 UTC. Note: You can create snapshots if cluster fullness is at stage 1, 2 or 3. You cannot create snapshots after cluster fullness reaches stage 4 or 5.

Parameters:schedule (Schedule) – [required] The “Schedule” object will be used to create a new schedule. Do not set ScheduleID property, it will be ignored. Frequency property must be of type that inherits from Frequency. Valid types are: DaysOfMonthFrequency DaysOrWeekFrequency TimeIntervalFrequency
schedule = <class 'solidfire.models.Schedule'>
class solidfire.models.CreateScheduleResult(schedule_id)[source]

Bases: solidfire.common.model.DataObject

Parameters:schedule_id (int) – [required]
schedule_id = <type 'int'>
class solidfire.models.CreateSnapMirrorEndpointRequest(management_ip, username, password)[source]

Bases: solidfire.common.model.DataObject

The SolidFire Element OS web UI uses the CreateSnapMirrorEndpoint method to create a relationship with a remote SnapMirror endpoint.

Parameters:
  • management_ip (str) – [required] The management IP address of the remote SnapMirror endpoint.
  • username (str) – [required] The management username for the ONTAP system.
  • password (str) – [required] The management password for the ONTAP system.
management_ip = <type 'str'>
password = <type 'str'>
username = <type 'str'>
class solidfire.models.CreateSnapMirrorEndpointResult(snap_mirror_endpoint)[source]

Bases: solidfire.common.model.DataObject

Parameters:snap_mirror_endpoint (SnapMirrorEndpoint) – [required] The newly created SnapMirror endpoint.
snap_mirror_endpoint = <class 'solidfire.models.SnapMirrorEndpoint'>
class solidfire.models.CreateSnapMirrorEndpointUnmanagedRequest(cluster_name, ip_addresses)[source]

Bases: solidfire.common.model.DataObject

The SolidFire system uses the CreateSnapMirrorEndpointUnmanaged method to enable remote, unmanaged SnapMirror endpoints to communicate with a SolidFire cluster. Unmanaged endpoints cannot be administered using the SolidFire SnapMirror APIs. They must be managed with ONTAP management software or APIs.

Parameters:
  • cluster_name (str) – [required] The name of the endpoint.
  • ip_addresses (str) – [required] The list of IP addresses for a cluster of ONTAP storage systems that should communicate with this SolidFire cluster.
cluster_name = <type 'str'>
ip_addresses = <type 'str[]'>
class solidfire.models.CreateSnapMirrorEndpointUnmanagedResult(snap_mirror_endpoint)[source]

Bases: solidfire.common.model.DataObject

Parameters:snap_mirror_endpoint (SnapMirrorEndpoint) – [required] The newly created SnapMirror endpoint.
snap_mirror_endpoint = <class 'solidfire.models.SnapMirrorEndpoint'>
class solidfire.models.CreateSnapMirrorRelationshipRequest(snap_mirror_endpoint_id, source_volume, destination_volume, relationship_type=None, policy_name=None, schedule_name=None, max_transfer_rate=None)[source]

Bases: solidfire.common.model.DataObject

The SolidFire Element OS web UI uses the CreateSnapMirrorRelationship method to create a SnapMirror extended data protection relationship between a source and destination endpoint.

Parameters:
  • snap_mirror_endpoint_id (int) – [required] The endpoint ID of the remote ONTAP storage system communicating with the SolidFire cluster.
  • source_volume (SnapMirrorVolumeInfo) – [required] The source volume in the relationship.
  • destination_volume (SnapMirrorVolumeInfo) – [required] The destination volume in the relationship.
  • relationship_type (str) – The type of relationship. On SolidFire systems, this value is always “extended_data_protection”.
  • policy_name (str) – Specifies the name of the ONTAP SnapMirror policy for the relationship. If not specified, the default policy name is MirrorLatest.
  • schedule_name (str) – The name of the preexisting cron schedule on the ONTAP system that is used to update the SnapMirror relationship. If no schedule is designated, snapMirror updates are not scheduled and must be updated manually.
  • max_transfer_rate (int) – Specifies the maximum data transfer rate between the volumes in kilobytes per second. The default value, 0, is unlimited and permits the SnapMirror relationship to fully utilize the available network bandwidth.
destination_volume = <class 'solidfire.models.SnapMirrorVolumeInfo'>
max_transfer_rate = <type 'int'>
policy_name = <type 'str'>
relationship_type = <type 'str'>
schedule_name = <type 'str'>
snap_mirror_endpoint_id = <type 'int'>
source_volume = <class 'solidfire.models.SnapMirrorVolumeInfo'>
class solidfire.models.CreateSnapMirrorRelationshipResult(snap_mirror_relationship)[source]

Bases: solidfire.common.model.DataObject

Parameters:snap_mirror_relationship (SnapMirrorRelationship) – [required] Information about the newly created SnapMirror relationship.
snap_mirror_relationship = <class 'solidfire.models.SnapMirrorRelationship'>
class solidfire.models.CreateSnapMirrorVolumeRequest(snap_mirror_endpoint_id, vserver, name, aggregate, size, type=None)[source]

Bases: solidfire.common.model.DataObject

The SolidFire Element OS web UI uses the CreateSnapMirrorVolume method to create a volume on the remote ONTAP system.

Parameters:
  • snap_mirror_endpoint_id (int) – [required] The endpoint ID of the remote ONTAP storage system communicating with the SolidFire cluster.
  • vserver (str) – [required] The name of the Vserver.
  • name (str) – [required] The destination ONTAP volume name.
  • type (str) – The volume type. Possible values: rw: Read-write volume ls: Load-sharing volume dp: Data protection volume If no type is provided the default type is dp.
  • aggregate (str) – [required] The containing ONTAP aggregate in which to create the volume. You can use ListSnapMirrorAggregates to get information about available ONTAP aggregates.
  • size (int) – [required] The size of the volume in bytes.
aggregate = <type 'str'>
name = <type 'str'>
size = <type 'int'>
snap_mirror_endpoint_id = <type 'int'>
type = <type 'str'>
vserver = <type 'str'>
class solidfire.models.CreateSnapshotRequest(volume_id, snapshot_id=None, name=None, enable_remote_replication=None, retention=None, attributes=None, snap_mirror_label=None)[source]

Bases: solidfire.common.model.DataObject

CreateSnapshot enables you to create a point-in-time copy of a volume. You can create a snapshot from any volume or from an existing snapshot. If you do not provide a SnapshotID with this API method, a snapshot is created from the volume’s active branch. If the volume from which the snapshot is created is being replicated to a remote cluster, the snapshot can also be replicated to the same target. Use the enableRemoteReplication parameter to enable snapshot replication. Note: Creating a snapshot is allowed if cluster fullness is at stage 2 or 3. Snapshots are not created when cluster fullness is at stage 4 or 5.

Parameters:
  • volume_id (int) – [required] Specifies the unique ID of the volume image from which to copy.
  • snapshot_id (int) – Specifies the unique ID of a snapshot from which the new snapshot is made. The snapshotID passed must be a snapshot on the given volume.
  • name (str) – Specifies a name for the snapshot. If unspecified, the date and time the snapshot was taken is used.
  • enable_remote_replication (bool) – Replicates the snapshot created to a remote cluster. Possible values are: true: The snapshot is replicated to remote storage. false: Default. The snapshot is not replicated.
  • retention (str) – Specifies the amount of time for which the snapshot is retained. The format is HH:mm:ss.
  • attributes (dict) – List of name-value pairs in JSON object format.
  • snap_mirror_label (str) – Label used by SnapMirror software to specify snapshot retention policy on SnapMirror endpoint.
attributes = <type 'dict'>
enable_remote_replication = <type 'bool'>
name = <type 'str'>
retention = <type 'str'>
snap_mirror_label = <type 'str'>
snapshot_id = <type 'int'>
volume_id = <type 'int'>
class solidfire.models.CreateSnapshotResult(snapshot, snapshot_id, checksum)[source]

Bases: solidfire.common.model.DataObject

Parameters:
  • snapshot (Snapshot) – [required]
  • snapshot_id (int) – [required] ID of the newly-created snapshot.
  • checksum (str) – [required] A string that represents the correct digits in the stored snapshot. This checksum can be used later to compare other snapshots to detect errors in the data.
checksum = <type 'str'>
snapshot = <class 'solidfire.models.Snapshot'>
snapshot_id = <type 'int'>
class solidfire.models.CreateStorageContainerRequest(name, initiator_secret=None, target_secret=None, account_id=None)[source]

Bases: solidfire.common.model.DataObject

CreateStorageContainer enables you to create a Virtual Volume (VVol) storage container. Storage containers are associated with a SolidFire storage system account, and are used for reporting and resource allocation. Storage containers can only be associated with virtual volumes. You need at least one storage container to use the Virtual Volumes feature.

Parameters:
  • name (str) – [required] The name of the storage container. Follows SolidFire account naming restrictions.
  • initiator_secret (str) – The secret for CHAP authentication for the initiator.
  • target_secret (str) – The secret for CHAP authentication for the target.
  • account_id (int) – Non-storage container account that will become a storage container.
account_id = <type 'int'>
initiator_secret = <type 'str'>
name = <type 'str'>
target_secret = <type 'str'>
class solidfire.models.CreateStorageContainerResult(storage_container)[source]

Bases: solidfire.common.model.DataObject

Parameters:storage_container (StorageContainer) – [required]
storage_container = <class 'solidfire.models.StorageContainer'>
class solidfire.models.CreateSupportBundleRequest(bundle_name=None, extra_args=None, timeout_sec=None)[source]

Bases: solidfire.common.model.DataObject

CreateSupportBundle enables you to create a support bundle file under the node’s directory. After creation, the bundle is stored on the node as a tar.gz file.

Parameters:
  • bundle_name (str) – The unique name for the support bundle. If no name is provided, “supportbundle” and the node name are used as the filename.
  • extra_args (str) – Passed to the sf_make_support_bundle script. You should use this parameter only at the request of NetApp SolidFire Support.
  • timeout_sec (int) – The number of seconds to allow the support bundle script to run before stopping. The default value is 1500 seconds.
bundle_name = <type 'str'>
extra_args = <type 'str'>
timeout_sec = <type 'int'>
class solidfire.models.CreateSupportBundleResult(details, duration, result)[source]

Bases: solidfire.common.model.DataObject

Parameters:
  • details (SupportBundleDetails) – [required] The details of the support bundle.
  • duration (str) – [required] The amount of time required to create the support bundle in the format HH:MM:SS.ssssss
  • result (str) – [required] Whether the support bundle creation passed or failed.
details = <class 'solidfire.models.SupportBundleDetails'>
duration = <type 'str'>
result = <type 'str'>
class solidfire.models.CreateVolumeAccessGroupRequest(name, initiators=None, volumes=None, virtual_network_id=None, virtual_network_tags=None, attributes=None)[source]

Bases: solidfire.common.model.DataObject

You can use CreateVolumeAccessGroup to create a new volume access group. When you create the volume access group, you need to give it a name, and you can optionally enter initiators and volumes. After you create the group, you can add volumes and initiator IQNs. Any initiator IQN that you add to the volume access group is able to access any volume in the group without CHAP authentication.

Parameters:
  • name (str) – [required] The name for this volume access group. Not required to be unique, but recommended.
  • initiators (str) – List of initiators to include in the volume access group. If unspecified, the access group’s configured initiators are not modified.
  • volumes (int) – List of volumes to initially include in the volume access group. If unspecified, the access group’s volumes are not modified.
  • virtual_network_id (int) – The ID of the SolidFire virtual network to associate the volume access group with.
  • virtual_network_tags (int) – The ID of the SolidFire virtual network to associate the volume access group with.
  • attributes (dict) – List of name-value pairs in JSON object format.
attributes = <type 'dict'>
initiators = <type 'str[]'>
name = <type 'str'>
virtual_network_id = <type 'int[]'>
virtual_network_tags = <type 'int[]'>
volumes = <type 'int[]'>
class solidfire.models.CreateVolumeAccessGroupResult(volume_access_group_id, volume_access_group=None)[source]

Bases: solidfire.common.model.DataObject

Parameters:
  • volume_access_group_id (int) – [required] The ID for the newly-created volume access group.
  • volume_access_group (VolumeAccessGroup) –
volume_access_group = <class 'solidfire.models.VolumeAccessGroup'>
volume_access_group_id = <type 'int'>
class solidfire.models.CreateVolumeRequest(name, account_id, total_size, enable512e=None, qos=None, attributes=None, associate_with_qos_policy=None, access=None, enable_snap_mirror_replication=None, qos_policy_id=None, protection_scheme=None)[source]

Bases: solidfire.common.model.DataObject

CreateVolume enables you to create a new (empty) volume on the cluster. As soon as the volume creation is complete, the volume is available for connection via iSCSI.

Parameters:
  • name (str) – [required] The name of the volume access group (might be user specified). Not required to be unique, but recommended. Might be 1 to 64 characters in length.
  • account_id (int) – [required] AccountID for the owner of this volume.
  • total_size (int) – [required] Total size of the volume, in bytes. Size is rounded up to the nearest 1MB size.
  • enable512e (bool) – Specifies whether 512e emulation is enabled or not. Possible values are: true: The volume provides 512-byte sector emulation. false: 512e emulation is not enabled.
  • qos (QoS) – Initial quality of service settings for this volume. Default values are used if none are specified. Valid settings are: minIOPS maxIOPS burstIOPS You can get the default values for a volume by using the GetDefaultQoS method.
  • attributes (dict) – The list of name-value pairs in JSON object format. Total attribute size must be less than 1000B, or 1KB, including JSON formatting characters.
  • associate_with_qos_policy (bool) – Associate the volume with the specified QoS policy. Possible values: true: Associate the volume with the QoS policy specified in the QoSPolicyID parameter. false: Do not assosciate the volume with the QoS policy specified in the QoSPolicyID parameter. When false, any existing policy association is removed regardless of whether you specify a QoS policy in the QoSPolicyID parameter.
  • access (str) – The access mode for the volume. Only snapMirrorTarget is allowed.
  • enable_snap_mirror_replication (bool) – Specifies whether SnapMirror replication is enabled or not.
  • qos_policy_id (int) – The ID for the policy whose QoS settings should be applied to the specified volumes. This parameter is mutually exclusive with the qos parameter.
  • protection_scheme (ProtectionScheme) – Protection scheme that should be used for this volume. The default value is the defaultProtectionScheme stored in the ClusterInfo object.
access = <type 'str'>
account_id = <type 'int'>
associate_with_qos_policy = <type 'bool'>
attributes = <type 'dict'>
enable512e = <type 'bool'>
enable_snap_mirror_replication = <type 'bool'>
name = <type 'str'>
protection_scheme = <class 'solidfire.models.ProtectionScheme'>
qos = <class 'solidfire.models.QoS'>
qos_policy_id = <type 'int'>
total_size = <type 'int'>
class solidfire.models.CreateVolumeResult(volume_id, curve, volume=None)[source]

Bases: solidfire.common.model.DataObject

Parameters:
  • volume (Volume) –
  • volume_id (int) – [required] VolumeID for the newly created volume.
  • curve (dict) – [required] The curve is a set of key-value pairs. The keys are I/O sizes in bytes. The values represent the cost of performing an IOP at a specific I/O size. The curve is calculated relative to a 4096 byte operation set at 100 IOPS.
curve = <type 'dict'>
volume = <class 'solidfire.models.Volume'>
volume_id = <type 'int'>
class solidfire.models.DayOfWeek(day, offset)[source]

Bases: solidfire.common.model.DataObject

DayOfWeek is an object that contains information about the day of the week for a Schedule

Parameters:
  • day (int) – [required] A number that represenents a day of the week. Must be 0-6 (Sunday-Saturday)
  • offset (int) – [required] The offset into the month, in weeks. For example, if the schedule should apply every week, offset=1. Every second week of the month, would be offset=2
day = <type 'int'>
offset = <type 'int'>
class solidfire.models.DeleteAllSupportBundlesResult(duration, details, result)[source]

Bases: solidfire.common.model.DataObject

Parameters:
  • duration (str) – [required]
  • details (dict) – [required]
  • result (str) – [required]
details = <type 'dict'>
duration = <type 'str'>
result = <type 'str'>
class solidfire.models.DeleteAuthSessionRequest(session_id)[source]

Bases: solidfire.common.model.DataObject

Deletes an individual auth session If the calling user is not in the ClusterAdmins / Administrator AccessGroup, only auth session belonging to the calling user can be deleted.

Parameters:session_id (UUID) – [required] UUID for the auth session to be deleted.
session_id = <class 'uuid.UUID'>
class solidfire.models.DeleteAuthSessionResult(session)[source]

Bases: solidfire.common.model.DataObject

Return value from DeleteAuthSession.

Parameters:session (AuthSessionInfo) – [required] SessionInfo for the auth session deleted.
session = <class 'solidfire.models.AuthSessionInfo'>
class solidfire.models.DeleteAuthSessionsByClusterAdminRequest(cluster_admin_id)[source]

Bases: solidfire.common.model.DataObject

Deletes all auth sessions associated with the specified ClusterAdminID. If the specified ClusterAdminID maps to a group of users, all auth sessions for all members of that group will be deleted. To see the list of sessions that could be deleted, use ListAuthSessionsByClusterAdmin with the same parameter.

Parameters:cluster_admin_id (int) – [required] ID that identifies a clusterAdmin.
cluster_admin_id = <type 'int'>
class solidfire.models.DeleteAuthSessionsByUsernameRequest(username=None, auth_method=None)[source]

Bases: solidfire.common.model.DataObject

Deletes all auth sessions for the given user. A caller not in AccessGroup ClusterAdmins / Administrator may only delete their own sessions. A caller with ClusterAdmins / Administrator privileges may delete sessions belonging to any user. To see the list of sessions that could be deleted, use ListAuthSessionsByUsername with the same parameters.

Parameters:
  • username (str) – Name that uniquely identifies the user. When authMethod is Cluster, this specifies the ClusterAdmin username. When authMethod is Ldap, this specifies the user’s LDAP DN. When authMethod is Idp, this may specify the user’s IdP uid or NameID. If the IdP is not configured to return either, this specifies a random UUID issued when the session was created. Only a caller in the ClusterAdmins / Administrator AccessGroup can provide this parameter.
  • auth_method (AuthMethod) – Authentication method of the user sessions to be deleted. Only a caller in the ClusterAdmins / Administrator AccessGroup can provide this parameter.
auth_method = <class 'solidfire.models.AuthMethod'>
username = <type 'str'>
class solidfire.models.DeleteAuthSessionsResult(sessions)[source]

Bases: solidfire.common.model.DataObject

Returns a list of AuthSessionInfos for those auth sessions deleted.

Parameters:sessions (AuthSessionInfo) – [required] SessionInfos for those auth sessions deleted.
sessions = <class 'solidfire.models.AuthSessionInfo[]'>
class solidfire.models.DeleteClusterInterfacePreferenceRequest(name)[source]

Bases: solidfire.common.model.DataObject

Deletes an existing cluster interface preference.

Parameters:name (str) – [required] Name of the cluster interface preference.
name = <type 'str'>
class solidfire.models.DeleteClusterInterfacePreferenceResult[source]

Bases: solidfire.common.model.DataObject

class solidfire.models.DeleteGroupSnapshotRequest(group_snapshot_id, save_members)[source]

Bases: solidfire.common.model.DataObject

DeleteGroupSnapshot enables you to delete a group snapshot. You can use the saveMembers parameter to preserve all the snapshots that were made for the volumes in the group, but the group association is removed.

Parameters:
  • group_snapshot_id (int) – [required] Specifies the unique ID of the group snapshot.
  • save_members (bool) – [required] Specifies whether to preserve snapshots or delete them. Valid values are: true: Snapshots are preserved, but group association is removed. false: The group and snapshots are deleted.
group_snapshot_id = <type 'int'>
save_members = <type 'bool'>
class solidfire.models.DeleteGroupSnapshotResult[source]

Bases: solidfire.common.model.DataObject

class solidfire.models.DeleteIdpConfigurationRequest(idp_configuration_id=None, idp_name=None)[source]

Bases: solidfire.common.model.DataObject

Delete an existing configuration with a third party Identity Provider (IdP) for the cluster. Deleting the last IdP Configuration will remove the SAML Service Provider certificate from the cluster.

Parameters:
  • idp_configuration_id (UUID) – UUID for the third party Identity Provider (IdP) Configuration.
  • idp_name (str) – Name for identifying and retrieving IdP provider for SAML 2.0 single sign-on.
idp_configuration_id = <class 'uuid.UUID'>
idp_name = <type 'str'>
class solidfire.models.DeleteIdpConfigurationResult[source]

Bases: solidfire.common.model.DataObject

class solidfire.models.DeleteInitiatorsRequest(initiators)[source]

Bases: solidfire.common.model.DataObject

DeleteInitiators enables you to delete one or more initiators from the system (and from any associated volumes or volume access groups). If DeleteInitiators fails to delete one of the initiators provided in the parameter, the system returns an error and does not delete any initiators (no partial completion is possible).

Parameters:initiators (int) – [required] An array of IDs of initiators to delete.
initiators = <type 'int[]'>
class solidfire.models.DeleteInitiatorsResult[source]

Bases: solidfire.common.model.DataObject

class solidfire.models.DeleteKeyProviderKmipRequest(key_provider_id)[source]

Bases: solidfire.common.model.DataObject

Delete the specified inactive Key Provider.

Parameters:key_provider_id (int) – [required] The ID of the Key Provider to delete.
key_provider_id = <type 'int'>
class solidfire.models.DeleteKeyProviderKmipResult[source]

Bases: solidfire.common.model.DataObject

There is no additional data returned as the delete is considered successful as long as there is no error.

class solidfire.models.DeleteKeyServerKmipRequest(key_server_id)[source]

Bases: solidfire.common.model.DataObject

Delete the specified KMIP (Key Management Interoperability Protocol) Key Server. A KMIP Key Server can be deleted unless it’s the last one assigned to its provider, and that provider is active (providing keys which are currently in use).

Parameters:key_server_id (int) – [required] The ID of the KMIP Key Server to delete.
key_server_id = <type 'int'>
class solidfire.models.DeleteKeyServerKmipResult[source]

Bases: solidfire.common.model.DataObject

There is no additional data returned as the delete is considered successful as long as there is no error.

class solidfire.models.DeleteQoSPolicyRequest(qos_policy_id)[source]

Bases: solidfire.common.model.DataObject

You can use the DeleteQoSPolicy method to delete a QoS policy from the system. The QoS settings for all volumes created of modified with this policy are unaffected.

Parameters:qos_policy_id (int) – [required] The ID of the QoS policy to be deleted.
qos_policy_id = <type 'int'>
class solidfire.models.DeleteQoSPolicyResult[source]

Bases: solidfire.common.model.DataObject

class solidfire.models.DeleteSnapMirrorEndpointsRequest(snap_mirror_endpoint_ids)[source]

Bases: solidfire.common.model.DataObject

The SolidFire Element OS web UI uses DeleteSnapMirrorEndpoints to delete one or more SnapMirror endpoints from the system.

Parameters:snap_mirror_endpoint_ids (int) – [required] An array of IDs of SnapMirror endpoints to delete.
snap_mirror_endpoint_ids = <type 'int[]'>
class solidfire.models.DeleteSnapMirrorEndpointsResult[source]

Bases: solidfire.common.model.DataObject

class solidfire.models.DeleteSnapMirrorRelationshipsRequest(snap_mirror_endpoint_id, destination_volumes)[source]

Bases: solidfire.common.model.DataObject

The SolidFire Element OS web UI uses the DeleteSnapMirrorRelationships method to remove one or more SnapMirror relationships between a source and destination endpoint.

Parameters:
  • snap_mirror_endpoint_id (int) – [required] The endpoint ID of the remote ONTAP storage system communicating with the SolidFire cluster.
  • destination_volumes (SnapMirrorVolumeInfo) – [required] The destination volume or volumes in the SnapMirror relationship.
destination_volumes = <class 'solidfire.models.SnapMirrorVolumeInfo[]'>
snap_mirror_endpoint_id = <type 'int'>
class solidfire.models.DeleteSnapMirrorRelationshipsResult(result)[source]

Bases: solidfire.common.model.DataObject

Parameters:result (str) – [required] If the delete action succeeded, this object contains a success message. If the action failed, it contains an error message.
result = <type 'str'>
class solidfire.models.DeleteSnapshotRequest(snapshot_id)[source]

Bases: solidfire.common.model.DataObject

DeleteSnapshot enables you to delete a snapshot. A snapshot that is currently the “active” snapshot cannot be deleted. You must rollback and make another snapshot “active” before the current snapshot can be deleted. For more details on rolling back snapshots, see RollbackToSnapshot.

Parameters:snapshot_id (int) – [required] The ID of the snapshot to be deleted.
snapshot_id = <type 'int'>
class solidfire.models.DeleteSnapshotResult[source]

Bases: solidfire.common.model.DataObject

class solidfire.models.DeleteStorageContainerResult[source]

Bases: solidfire.common.model.DataObject

class solidfire.models.DeleteStorageContainersRequest(storage_container_ids)[source]

Bases: solidfire.common.model.DataObject

DeleteStorageContainers enables you to remove up to 2000 Virtual Volume (VVol) storage containers from the system at one time. The storage containers you remove must not contain any VVols.

Parameters:storage_container_ids (UUID) – [required] A list of IDs of the storage containers to delete. You can specify up to 2000 IDs in the list.
storage_container_ids = <class 'uuid.UUID[]'>
class solidfire.models.DeleteVolumeAccessGroupRequest(volume_access_group_id, delete_orphan_initiators=None)[source]

Bases: solidfire.common.model.DataObject

DeleteVolumeAccessGroup enables you to delete a volume access group.

Parameters:
  • volume_access_group_id (int) – [required] The ID of the volume access group to be deleted.
  • delete_orphan_initiators (bool) – true: Default. Delete initiator objects after they are removed from a volume access group. false: Do not delete initiator objects after they are removed from a volume access group.
delete_orphan_initiators = <type 'bool'>
volume_access_group_id = <type 'int'>
class solidfire.models.DeleteVolumeAccessGroupResult[source]

Bases: solidfire.common.model.DataObject

class solidfire.models.DeleteVolumeRequest(volume_id)[source]

Bases: solidfire.common.model.DataObject

DeleteVolume marks an active volume for deletion. When marked, the volume is purged (permanently deleted) after the cleanup interval elapses. After making a request to delete a volume, any active iSCSI connections to the volume are immediately terminated and no further connections are allowed while the volume is in this state. A marked volume is not returned in target discovery requests. Any snapshots of a volume that has been marked for deletion are not affected. Snapshots are kept until the volume is purged from the system. If a volume is marked for deletion and has a bulk volume read or bulk volume write operation in progress, the bulk volume read or write operation is stopped. If the volume you delete is paired with a volume, replication between the paired volumes is suspended and no data is transferred to it or from it while in a deleted state. The remote volume that the deleted volume was paired with enters into a PausedMisconfigured state and data is no longer sent to it or from the deleted volume. Until the deleted volume is purged, it can be restored and data transfers resume. If the deleted volume gets purged from the system, the volume it was paired with enters into a StoppedMisconfigured state and the volume pairing status is removed. The purged volume becomes permanently unavailable.

Parameters:volume_id (int) – [required] The ID of the volume to be deleted.
volume_id = <type 'int'>
class solidfire.models.DeleteVolumeResult(volume=None)[source]

Bases: solidfire.common.model.DataObject

Parameters:volume (Volume) –
volume = <class 'solidfire.models.Volume'>
class solidfire.models.DeleteVolumesRequest(account_ids=None, volume_access_group_ids=None, volume_ids=None)[source]

Bases: solidfire.common.model.DataObject

DeleteVolumes marks multiple (up to 500) active volumes for deletion. Once marked, the volumes are purged (permanently deleted) after the cleanup interval elapses. The cleanup interval can be set in the SetClusterSettings method. For more information on using this method, see SetClusterSettings on page 1. After making a request to delete volumes, any active iSCSI connections to the volumes are immediately terminated and no further connections are allowed while the volumes are in this state. A marked volume is not returned in target discovery requests. Any snapshots of a volume that has been marked for deletion are not affected. Snapshots are kept until the volume is purged from the system. If a volume is marked for deletion and has a bulk volume read or bulk volume write operation in progress, the bulk volume read or write operation is stopped. If the volumes you delete are paired with a volume, replication between the paired volumes is suspended and no data is transferred to them or from them while in a deleted state. The remote volumes the deleted volumes were paired with enter into a PausedMisconfigured state and data is no longer sent to them or from the deleted volumes. Until the deleted volumes are purged, they can be restored and data transfers resume. If the deleted volumes are purged from the system, the volumes they were paired with enter into a StoppedMisconfigured state and the volume pairing status is removed. The purged volumes become permanently unavailable.

Parameters:
  • account_ids (int) – A list of account IDs. All volumes from these accounts are deleted from the system.
  • volume_access_group_ids (int) – A list of volume access group IDs. All of the volumes from all of the volume access groups you specify in this list are deleted from the system.
  • volume_ids (int) – The list of IDs of the volumes to delete from the system.
account_ids = <type 'int[]'>
volume_access_group_ids = <type 'int[]'>
volume_ids = <type 'int[]'>
class solidfire.models.DeleteVolumesResult(volumes)[source]

Bases: solidfire.common.model.DataObject

Parameters:volumes (Volume) – [required] Information about the newly deleted volume.
volumes = <class 'solidfire.models.Volume[]'>
class solidfire.models.DetailedService(service, node, drives, drive=None)[source]

Bases: solidfire.common.model.DataObject

Parameters:
  • service (Service) – [required]
  • node (Node) – [required]
  • drive (Drive) –
  • drives (Drive) – [required]
drive = <class 'solidfire.models.Drive'>
drives = <class 'solidfire.models.Drive[]'>
node = <class 'solidfire.models.Node'>
service = <class 'solidfire.models.Service'>
class solidfire.models.DisableBmcColdResetResult(c_bmc_reset_duration_minutes)[source]

Bases: solidfire.common.model.DataObject

DisableBmcColdResetResult returns the time between reset intervals. The interval should always be 0 after the command completes.

Parameters:c_bmc_reset_duration_minutes (int) – [required] This value will be 0 if the command completes succesfully
c_bmc_reset_duration_minutes = <type 'int'>
class solidfire.models.DisableClusterSshResult(enabled, time_remaining, nodes)[source]

Bases: solidfire.common.model.DataObject

Parameters:
  • enabled (bool) – [required] Status of SSH on the cluster.
  • time_remaining (str) – [required] Time remaining until SSH is disable on the cluster.
  • nodes (NodeSshInfo) – [required] Time remaining until SSH is disable on the cluster.
enabled = <type 'bool'>
nodes = <class 'solidfire.models.NodeSshInfo[]'>
time_remaining = <type 'str'>
class solidfire.models.DisableEncryptionAtRestResult[source]

Bases: solidfire.common.model.DataObject

class solidfire.models.DisableIdpAuthenticationResult[source]

Bases: solidfire.common.model.DataObject

class solidfire.models.DisableLdapAuthenticationResult[source]

Bases: solidfire.common.model.DataObject

class solidfire.models.DisableMaintenanceModeRequest(nodes)[source]

Bases: solidfire.common.model.DataObject

Take a node out of maintenance mode. This should be called after maintenance is complete and the node is online.

Parameters:nodes (int) – [required] List of NodeIDs to take out of maintenance mode
nodes = <type 'int[]'>
class solidfire.models.DisableSnmpResult[source]

Bases: solidfire.common.model.DataObject

class solidfire.models.DisableSshResult(enabled)[source]

Bases: solidfire.common.model.DataObject

Parameters:enabled (bool) – [required] The status of the SSH service for this node.
enabled = <type 'bool'>
class solidfire.models.Drive(drive_id, node_id, async_result_ids, capacity, usable_capacity, segment_file_size, serial, drive_status, drive_type, attributes, assigned_service=None, slot=None, drive_failure_detail=None, drive_security_fault_reason=None, key_provider_id=None, key_id=None, reserved_slice_file_capacity=None, customer_slice_file_capacity=None, smart_ssd_write_capable=None, skip_label=None)[source]

Bases: solidfire.common.model.DataObject

Parameters:
  • drive_id (int) – [required] A unique identifier for this drive.
  • node_id (int) – [required] The node this drive is located. If the drive has been physically removed from the node, this is where it was last seen.
  • assigned_service (int) – If this drive is hosting a service, the identifier for that service.
  • async_result_ids (int) – [required] The list of asynchronous jobs currently running on the drive (for example: a secure erase job).
  • capacity (int) – [required] Total Raw capacity of the drive, in bytes.
  • usable_capacity (int) – [required] Total Usable capacity of the drive, in bytes.
  • segment_file_size (int) – [required] Segment File Size of the drive, in bytes.
  • serial (str) – [required] The manufacturer’s serial number for this drive.
  • slot (int) – Slot number in the server chassis where this drive is located. If the drive has been physically removed from the node, this will not have a value.
  • drive_status (str) – [required] The current status of this drive.
  • drive_failure_detail (str) – If a drive’s status is ‘Failed’, this field provides more detail on why the drive was marked failed.
  • drive_security_fault_reason (str) – If enabling or disabling drive security failed, this is the reason why it failed. If the value is ‘none’, there was no failure.
  • key_provider_id (int) – Identifies the provider of the authentication key for unlocking this drive.
  • key_id (UUID) – The keyID used by the key provider to acquire the authentication key for unlocking this drive.
  • drive_type (str) – [required] The type of this drive.
  • reserved_slice_file_capacity (int) –
  • customer_slice_file_capacity (int) –
  • smart_ssd_write_capable (bool) –
  • skip_label (bool) – Whether or not Element software will avoid writing to LBA 0 of this drive.
  • attributes (dict) – [required] List of Name/Value pairs in JSON object format.
assigned_service = <type 'int'>
async_result_ids = <type 'int[]'>
attributes = <type 'dict'>
capacity = <type 'int'>
customer_slice_file_capacity = <type 'int'>
drive_failure_detail = <type 'str'>
drive_id = <type 'int'>
drive_security_fault_reason = <type 'str'>
drive_status = <type 'str'>
drive_type = <type 'str'>
key_id = <class 'uuid.UUID'>
key_provider_id = <type 'int'>
node_id = <type 'int'>
reserved_slice_file_capacity = <type 'int'>
segment_file_size = <type 'int'>
serial = <type 'str'>
skip_label = <type 'bool'>
slot = <type 'int'>
smart_ssd_write_capable = <type 'bool'>
usable_capacity = <type 'int'>
class solidfire.models.DriveConfigInfo(canonical_name, connected, dev, dev_path, drive_type, product, name, path, path_link, scsi_compat_id, security_enabled, security_frozen, security_locked, security_supported, size, slot, uuid, vendor, version, security_at_maximum, serial, scsi_state, smart_ssd_write_capable=None)[source]

Bases: solidfire.common.model.DataObject

Parameters:
  • canonical_name (str) – [required]
  • connected (bool) – [required]
  • dev (int) – [required]
  • dev_path (str) – [required]
  • drive_type (str) – [required]
  • product (str) – [required]
  • name (str) – [required]
  • path (str) – [required]
  • path_link (str) – [required]
  • scsi_compat_id (str) – [required]
  • smart_ssd_write_capable (bool) –
  • security_enabled (bool) – [required]
  • security_frozen (bool) – [required]
  • security_locked (bool) – [required]
  • security_supported (bool) – [required]
  • size (int) – [required]
  • slot (int) – [required]
  • uuid (UUID) – [required]
  • vendor (str) – [required]
  • version (str) – [required]
  • security_at_maximum (bool) – [required]
  • serial (str) – [required]
  • scsi_state (str) – [required]
canonical_name = <type 'str'>
connected = <type 'bool'>
dev = <type 'int'>
dev_path = <type 'str'>
drive_type = <type 'str'>
name = <type 'str'>
path = <type 'str'>
product = <type 'str'>
scsi_compat_id = <type 'str'>
scsi_state = <type 'str'>
security_at_maximum = <type 'bool'>
security_enabled = <type 'bool'>
security_frozen = <type 'bool'>
security_locked = <type 'bool'>
security_supported = <type 'bool'>
serial = <type 'str'>
size = <type 'int'>
slot = <type 'int'>
smart_ssd_write_capable = <type 'bool'>
uuid = <class 'uuid.UUID'>
vendor = <type 'str'>
version = <type 'str'>
class solidfire.models.DriveEncryptionCapabilityType(value)[source]

Bases: solidfire.common.model.DataObject

This specifies a drive’s encryption capability.

enum_values = (u'none', u'sed', u'fips')
get_value()[source]
class solidfire.models.DriveHardware(canonical_name, connected, dev, dev_path, drive_type, drive_encryption_capability, life_remaining_percent, lifetime_read_bytes, lifetime_write_bytes, name, path, path_link, power_on_hours, product, reallocated_sectors, reserve_capacity_percent, scsi_compat_id, scsi_state, security_at_maximum, security_enabled, security_frozen, security_locked, security_supported, serial, size, slot, uuid, vendor, version, smart_ssd_write_capable=None)[source]

Bases: solidfire.common.model.DataObject

Parameters:
  • canonical_name (str) – [required]
  • connected (bool) – [required]
  • dev (int) – [required]
  • dev_path (str) – [required]
  • drive_type (str) – [required]
  • drive_encryption_capability (DriveEncryptionCapabilityType) – [required]
  • life_remaining_percent (int) – [required]
  • lifetime_read_bytes (int) – [required]
  • lifetime_write_bytes (int) – [required]
  • name (str) – [required]
  • path (str) – [required]
  • path_link (str) – [required]
  • power_on_hours (int) – [required]
  • product (str) – [required]
  • reallocated_sectors (int) – [required]
  • reserve_capacity_percent (int) – [required]
  • scsi_compat_id (str) – [required]
  • scsi_state (str) – [required]
  • security_at_maximum (bool) – [required]
  • security_enabled (bool) – [required]
  • security_frozen (bool) – [required]
  • security_locked (bool) – [required]
  • security_supported (bool) – [required]
  • serial (str) – [required]
  • size (int) – [required]
  • slot (int) – [required]
  • smart_ssd_write_capable (bool) –
  • uuid (UUID) – [required]
  • vendor (str) – [required]
  • version (str) – [required]
canonical_name = <type 'str'>
connected = <type 'bool'>
dev = <type 'int'>
dev_path = <type 'str'>
drive_encryption_capability = <class 'solidfire.models.DriveEncryptionCapabilityType'>
drive_type = <type 'str'>
life_remaining_percent = <type 'int'>
lifetime_read_bytes = <type 'int'>
lifetime_write_bytes = <type 'int'>
name = <type 'str'>
path = <type 'str'>
power_on_hours = <type 'int'>
product = <type 'str'>
reallocated_sectors = <type 'int'>
reserve_capacity_percent = <type 'int'>
scsi_compat_id = <type 'str'>
scsi_state = <type 'str'>
security_at_maximum = <type 'bool'>
security_enabled = <type 'bool'>
security_frozen = <type 'bool'>
security_locked = <type 'bool'>
security_supported = <type 'bool'>
serial = <type 'str'>
size = <type 'int'>
slot = <type 'int'>
smart_ssd_write_capable = <type 'bool'>
uuid = <class 'uuid.UUID'>
vendor = <type 'str'>
version = <type 'str'>
class solidfire.models.DriveHardwareInfo(description, dev, devpath, drive_security_at_maximum, drive_security_frozen, drive_security_locked, logicalname, product, scsi_compat_id, security_feature_enabled, security_feature_supported, serial, size, uuid, version)[source]

Bases: solidfire.common.model.DataObject

Parameters:
  • description (str) – [required]
  • dev (str) – [required]
  • devpath (str) – [required]
  • drive_security_at_maximum (bool) – [required]
  • drive_security_frozen (bool) – [required]
  • drive_security_locked (bool) – [required]
  • logicalname (str) – [required]
  • product (str) – [required]
  • scsi_compat_id (str) – [required]
  • security_feature_enabled (bool) – [required]
  • security_feature_supported (bool) – [required]
  • serial (str) – [required]
  • size (int) – [required]
  • uuid (UUID) – [required]
  • version (str) – [required]
description = <type 'str'>
dev = <type 'str'>
devpath = <type 'str'>
drive_security_at_maximum = <type 'bool'>
drive_security_frozen = <type 'bool'>
drive_security_locked = <type 'bool'>
logicalname = <type 'str'>
product = <type 'str'>
scsi_compat_id = <type 'str'>
security_feature_enabled = <type 'bool'>
security_feature_supported = <type 'bool'>
serial = <type 'str'>
size = <type 'int'>
uuid = <class 'uuid.UUID'>
version = <type 'str'>
class solidfire.models.DriveInfo(capacity, usable_capacity, segment_file_size, drive_id, node_id, serial, chassis_slot, slot, status, type, attributes, drive_failure_detail=None, drive_security_fault_reason=None, key_provider_id=None, key_id=None)[source]

Bases: solidfire.common.model.DataObject

Parameters:
  • capacity (int) – [required] Total Raw capacity of the drive, in bytes.
  • usable_capacity (int) – [required] Total Usable capacity of the drive, in bytes.
  • segment_file_size (int) – [required] Segment File Size of the drive, in bytes.
  • drive_id (int) – [required] DriveID for this drive.
  • node_id (int) – [required] NodeID where this drive is located.
  • serial (str) – [required] Drive serial number.
  • chassis_slot (str) – [required] For HCI platforms, this value is the node letter and slot number in the server chassis where this drive is located. For legacy platforms, the slot number is a string representation of the ‘slot’ integer.
  • slot (int) – [required] Slot number in the server chassis where this drive is located, or -1 if SATADimm used for internal metadata drive.
  • status (str) – [required]
  • drive_failure_detail (str) – If a drive’s status is ‘Failed’, this field provides more detail on why the drive was marked failed.
  • drive_security_fault_reason (str) – If enabling or disabling drive security failed, this is the reason why it failed. If the value is ‘none’, there was no failure.
  • key_provider_id (int) – Identifies the provider of the authentication key for unlocking this drive.
  • key_id (UUID) – The keyID used by the key provider to acquire the authentication key for unlocking this drive.
  • type (str) – [required]
  • attributes (dict) – [required] List of Name/Value pairs in JSON object format.
attributes = <type 'dict'>
capacity = <type 'int'>
chassis_slot = <type 'str'>
drive_failure_detail = <type 'str'>
drive_id = <type 'int'>
drive_security_fault_reason = <type 'str'>
key_id = <class 'uuid.UUID'>
key_provider_id = <type 'int'>
node_id = <type 'int'>
segment_file_size = <type 'int'>
serial = <type 'str'>
slot = <type 'int'>
status = <type 'str'>
type = <type 'str'>
usable_capacity = <type 'int'>
class solidfire.models.DriveStats(failed_die_count, life_remaining_percent, lifetime_read_bytes, lifetime_write_bytes, power_on_hours, read_bytes, read_ops, reallocated_sectors, reserve_capacity_percent, timestamp, total_capacity, used_memory, write_bytes, write_ops, active_sessions=None, drive_id=None, used_capacity=None)[source]

Bases: solidfire.common.model.DataObject

Parameters:
  • active_sessions (int) –
  • drive_id (int) –
  • failed_die_count (int) – [required]
  • life_remaining_percent (int) – [required]
  • lifetime_read_bytes (int) – [required]
  • lifetime_write_bytes (int) – [required]
  • power_on_hours (int) – [required]
  • read_bytes (int) – [required]
  • read_ops (int) – [required]
  • reallocated_sectors (int) – [required]
  • reserve_capacity_percent (int) – [required]
  • timestamp (str) – [required]
  • total_capacity (int) – [required]
  • used_capacity (int) –
  • used_memory (int) – [required]
  • write_bytes (int) – [required]
  • write_ops (int) – [required]
active_sessions = <type 'int'>
drive_id = <type 'int'>
failed_die_count = <type 'int'>
life_remaining_percent = <type 'int'>
lifetime_read_bytes = <type 'int'>
lifetime_write_bytes = <type 'int'>
power_on_hours = <type 'int'>
read_bytes = <type 'int'>
read_ops = <type 'int'>
reallocated_sectors = <type 'int'>
reserve_capacity_percent = <type 'int'>
timestamp = <type 'str'>
total_capacity = <type 'int'>
used_capacity = <type 'int'>
used_memory = <type 'int'>
write_bytes = <type 'int'>
write_ops = <type 'int'>
class solidfire.models.DrivesConfigInfo(drives, num_block_actual, num_block_expected, num_slice_actual, num_slice_expected, num_total_actual, num_total_expected)[source]

Bases: solidfire.common.model.DataObject

Parameters:
  • drives (DriveConfigInfo) – [required]
  • num_block_actual (int) – [required]
  • num_block_expected (int) – [required]
  • num_slice_actual (int) – [required]
  • num_slice_expected (int) – [required]
  • num_total_actual (int) – [required]
  • num_total_expected (int) – [required]
drives = <class 'solidfire.models.DriveConfigInfo[]'>
num_block_actual = <type 'int'>
num_block_expected = <type 'int'>
num_slice_actual = <type 'int'>
num_slice_expected = <type 'int'>
num_total_actual = <type 'int'>
num_total_expected = <type 'int'>
class solidfire.models.DrivesHardware(drive_hardware)[source]

Bases: solidfire.common.model.DataObject

Parameters:drive_hardware (DriveHardware) – [required]
drive_hardware = <class 'solidfire.models.DriveHardware[]'>
class solidfire.models.EnableBmcColdResetRequest(timeout=None)[source]

Bases: solidfire.common.model.DataObject

EnableBmcColdReset enables a background task that periodically resets the Baseboard Management Controller (BMC) for all nodes in the cluster.

Parameters:timeout (int) – If set, the time between BMC reset operations in minutes. The default is 20160 minutes.
timeout = <type 'int'>
class solidfire.models.EnableBmcColdResetResult(c_bmc_reset_duration_minutes)[source]

Bases: solidfire.common.model.DataObject

EnableBmcColdReset returns the time between reset intervals.

Parameters:c_bmc_reset_duration_minutes (int) – [required] This is the time between BMC resets.
c_bmc_reset_duration_minutes = <type 'int'>
class solidfire.models.EnableClusterSshRequest(duration)[source]

Bases: solidfire.common.model.DataObject

Enables SSH on all nodes in the cluster. Overwrites previous duration.

Parameters:duration (str) – [required] The duration on how long SSH will be enable on the cluster. Follows format “HH:MM:SS.MS”.
duration = <type 'str'>
class solidfire.models.EnableClusterSshResult(enabled, time_remaining, nodes)[source]

Bases: solidfire.common.model.DataObject

Parameters:
  • enabled (bool) – [required] Status of SSH on the cluster.
  • time_remaining (str) – [required] Time remaining until SSH is disable on the cluster.
  • nodes (NodeSshInfo) – [required] SSH information for each node in the cluster.
enabled = <type 'bool'>
nodes = <class 'solidfire.models.NodeSshInfo[]'>
time_remaining = <type 'str'>
class solidfire.models.EnableEncryptionAtRestRequest(key_provider_id=None)[source]

Bases: solidfire.common.model.DataObject

Initiate the process of setting a password on self-encrypting drives (SEDs) within the cluster. This feature is not enabled by default but can be toggled on and off as needed. If a password is set on a SED which is removed from the cluster, the password will remain set and the drive is not secure erased. Data can be secure erased using the SecureEraseDrives API method. Note: This does not affect performance or efficiency. If no parameters are specified, the password will be generated internally and at random (the only option for endpoints prior to 12.0). This generated password will be distributed across the nodes using Shamir’s Secret Sharing Algorithm such that at least two nodes are required to reconstruct the password. The complete password to unlock the drives is not stored on any single node and is never sent across the network in its entirety. This protects against the theft of any number of drives or a single node. If a keyProviderID is specified then the password will be generated/retrieved as appropriate per the type of provider. Commonly this would be via a KMIP (Key Management Interoperability Protocol) Key Server in the case of a KMIP Key Provider (see CreateKeyProviderKmip). After this operation the specified provider will be considered ‘active’ and will not be able to be deleted until DisableEncryptionAtRest is called.

Parameters:key_provider_id (int) – The ID of a Key Provider to use. This is a unique value returned as part of one of the CreateKeyProvider* methods.
key_provider_id = <type 'int'>
class solidfire.models.EnableEncryptionAtRestResult[source]

Bases: solidfire.common.model.DataObject

class solidfire.models.EnableFeatureRequest(feature)[source]

Bases: solidfire.common.model.DataObject

You can use EnableFeature to enable cluster features that are disabled by default.

Parameters:feature (str) – [required] Indicates which feature to enable. Valid values are: vvols: Enable the NetApp SolidFire VVols cluster feature. FipsDrives: Enable the NetApp SolidFire cluster FIPS 140-2 drive support. Fips: Enable FIPS 140-2 certified encryption for HTTPS communications. SnapMirror: Enable the SnapMirror replication cluster feature.
feature = <type 'str'>
class solidfire.models.EnableFeatureResult[source]

Bases: solidfire.common.model.DataObject

class solidfire.models.EnableIdpAuthenticationRequest(idp_configuration_id=None)[source]

Bases: solidfire.common.model.DataObject

Enable support for authentication using a third party Identity Provider (IdP) for the cluster. Once IdP authentication is enabled, cluster and Ldap admins will no longer be able to access the cluster via supported UIs and any active authenticated sessions will be invalidated/logged out. Only third party IdP authenticated users will be able to access the cluster via the supported UIs.

Parameters:idp_configuration_id (UUID) – UUID for the third party Identity Provider (IdP) Configuration. If only one IdP Configuration exists, then we will default to enabling that configuration.
idp_configuration_id = <class 'uuid.UUID'>
class solidfire.models.EnableIdpAuthenticationResult[source]

Bases: solidfire.common.model.DataObject

class solidfire.models.EnableLdapAuthenticationRequest(server_uris, auth_type=None, group_search_base_dn=None, group_search_custom_filter=None, group_search_type=None, search_bind_dn=None, search_bind_password=None, user_dntemplate=None, user_search_base_dn=None, user_search_filter=None)[source]

Bases: solidfire.common.model.DataObject

The EnableLdapAuthentication method enables you to configure an LDAP directory connection to use for LDAP authentication to a cluster. Users that are members of the LDAP directory can then log in to the storage system using their LDAP credentials.

Parameters:
  • auth_type (str) – Identifies which user authentication method to use. Must be one of the following: DirectBind SearchAndBind
  • group_search_base_dn (str) – The base DN of the tree to start the group search (will do a subtree search from here).
  • group_search_custom_filter (str) – For use with the CustomFilter search type, an LDAP filter to use to return the DNs of a users groups. The string can have placeholder text of %USERNAME% and %USERDN% to be replaced with their username and full userDN as needed.
  • group_search_type (str) – Controls the default group search filter used, and must be one of the following: NoGroups: No group support. ActiveDirectory: Nested membership of all of a users AD groups. MemberDN: MemberDN style groups (single level).
  • search_bind_dn (str) – A fully qualified DN to log in with to perform an LDAP search for the user (needs read access to the LDAP directory).
  • search_bind_password (str) – The password for the searchBindDN account used for searching.
  • server_uris (str) – [required] A comma-separated list of LDAP server URIs (examples: “ldap://1.2.3.4” and ldaps://1.2.3.4:123”)
  • user_dntemplate (str) – A string that is used to form a fully qualified user DN. The string should have the placeholder text %USERNAME%, which is replaced with the username of the authenticating user.
  • user_search_base_dn (str) – The base DN of the tree to start the search (will do a subtree search from here).
  • user_search_filter (str) – The LDAP filter to use. The string should have the placeholder text %USERNAME% which is replaced with the username of the authenticating user. Example: (&(objectClass=person)(sAMAccountName=%USERNAME%)) will use the sAMAccountName field in Active Directory to match the username entered at cluster login.
auth_type = <type 'str'>
group_search_base_dn = <type 'str'>
group_search_custom_filter = <type 'str'>
group_search_type = <type 'str'>
search_bind_dn = <type 'str'>
search_bind_password = <type 'str'>
server_uris = <type 'str[]'>
user_dntemplate = <type 'str'>
user_search_base_dn = <type 'str'>
user_search_filter = <type 'str'>
class solidfire.models.EnableLdapAuthenticationResult[source]

Bases: solidfire.common.model.DataObject

class solidfire.models.EnableMaintenanceModeRequest(nodes, per_minute_primary_swap_limit=None, timeout=None, force_with_unresolved_faults=None)[source]

Bases: solidfire.common.model.DataObject

Prepare a node for maintenance. Maintenance includes anything that will require the node to be powered-off or restarted.

Parameters:
  • nodes (int) – [required] List of NodeIDs to put in maintenance mode
  • per_minute_primary_swap_limit (int) – Number of primaries to swap per minute. If not specified, all will be swapped at once.
  • timeout (str) – How long to allow maintenance mode to remain enabled before automatically disabling. Formatted in HH:mm:ss. If not specified, it will remain enabled until explicitly disabled
  • force_with_unresolved_faults (bool) – Force maintenance mode to be enabled even with blocking cluster faults present.
force_with_unresolved_faults = <type 'bool'>
nodes = <type 'int[]'>
per_minute_primary_swap_limit = <type 'int'>
timeout = <type 'str'>
class solidfire.models.EnableSnmpRequest(snmp_v3_enabled)[source]

Bases: solidfire.common.model.DataObject

EnableSnmp enables you to enable SNMP on cluster nodes. When you enable SNMP, the action applies to all nodes in the cluster, and the values that are passed replace, in whole, all values set in any previous call to EnableSnmp.

Parameters:snmp_v3_enabled (bool) – [required] If set to “true”, then SNMP v3 is enabled on each node in the cluster. If set to “false”, then SNMP v2 is enabled.
snmp_v3_enabled = <type 'bool'>
class solidfire.models.EnableSnmpResult[source]

Bases: solidfire.common.model.DataObject

class solidfire.models.EnableSshResult(enabled)[source]

Bases: solidfire.common.model.DataObject

Parameters:enabled (bool) – [required] The status of the SSH service for this node.
enabled = <type 'bool'>
class solidfire.models.EventInfo(event_id, severity, event_info_type, message, service_id, node_id, drive_id, drive_ids, time_of_report, time_of_publish, details=None)[source]

Bases: solidfire.common.model.DataObject

Parameters:
  • event_id (int) – [required] ID of event.
  • severity (int) – [required] Unused
  • event_info_type (str) – [required] Event type.
  • message (str) – [required] The message associated with the event.
  • service_id (int) – [required] ServiceID associated with the event.
  • node_id (int) – [required] NodeID associated with the event.
  • drive_id (int) – [required] Derived from driveIDs field. Either the first item in driveIDs array, or empty.
  • drive_ids (int) – [required] Drive IDs associated with the event.
  • time_of_report (str) – [required] The time this event was reported.
  • time_of_publish (str) – [required] The time this event was published into the database.
  • details (str) – Data assoicated with the event, such as data report or exception details.
details = <type 'str'>
drive_id = <type 'int'>
drive_ids = <type 'int[]'>
event_id = <type 'int'>
event_info_type = <type 'str'>
message = <type 'str'>
node_id = <type 'int'>
service_id = <type 'int'>
severity = <type 'int'>
time_of_publish = <type 'str'>
time_of_report = <type 'str'>
class solidfire.models.FeatureObject(enabled, feature)[source]

Bases: solidfire.common.model.DataObject

Parameters:
  • enabled (bool) – [required] True if the feature is enabled, otherwise false.
  • feature (str) – [required] The name of the feature.
enabled = <type 'bool'>
feature = <type 'str'>
class solidfire.models.FibreChannelPortInfo(firmware, hba_port, model, n_port_id, pci_slot, serial, speed, state, switch_wwn, wwnn, wwpn)[source]

Bases: solidfire.common.model.DataObject

Fibre Channel Node Port Info object returns information about all Fibre Channel ports on a node, or for one node in the cluster. The same information is returned for all ports or port information for one node. This information is returned with the API method ListNodeFibreChannelPortInfo (in the SolidFire API Guide).

Parameters:
  • firmware (str) – [required] The version of the firmware installed on the Fibre Channel port.
  • hba_port (int) – [required] The ID of the individual HBA port.
  • model (str) – [required] Model of the HBA on the port.
  • n_port_id (str) – [required] Unique SolidFire port node ID.
  • pci_slot (int) – [required] Slot in which the pci card resides on the Fibre Channel node hardware.
  • serial (str) – [required] Serial number on the Fibre Channel port.
  • speed (str) – [required] Speed of the HBA on the port.
  • state (str) – [required] Possible values: <strong>UnknownNotPresentOnlineOfflineBlockedBypassedDiagnosticsLinkdownErrorLoopbackDeleted</strong>
  • switch_wwn (str) – [required] The World Wide Name of the Fibre Channel switch port.
  • wwnn (str) – [required] World Wide Node Name of the HBA node.
  • wwpn (str) – [required] World Wide Port Name assigned to the physical port of the HBA.
firmware = <type 'str'>
hba_port = <type 'int'>
model = <type 'str'>
n_port_id = <type 'str'>
pci_slot = <type 'int'>
serial = <type 'str'>
speed = <type 'str'>
state = <type 'str'>
switch_wwn = <type 'str'>
wwnn = <type 'str'>
wwpn = <type 'str'>
class solidfire.models.FibreChannelPortInfoResult(result)[source]

Bases: solidfire.common.model.DataObject

Used to return information about the Fibre Channel ports.

Parameters:result (FibreChannelPortList) – [required] Used to return information about the Fibre Channel ports.
result = <class 'solidfire.models.FibreChannelPortList'>
class solidfire.models.FibreChannelPortList(fibre_channel_ports)[source]

Bases: solidfire.common.model.DataObject

List of all Fibre Channel ports.

Parameters:fibre_channel_ports (FibreChannelPortInfo) – [required] List of all physical Fibre Channel ports.
fibre_channel_ports = <class 'solidfire.models.FibreChannelPortInfo[]'>
class solidfire.models.FibreChannelSession(initiator_wwpn, node_id, service_id, target_wwpn, volume_access_group_id=None)[source]

Bases: solidfire.common.model.DataObject

FibreChannelSession contains information about each Fibre Channel session that is visible to the cluster and what target ports it is visible on.

Parameters:
  • initiator_wwpn (str) – [required] The WWPN of the initiator which is logged into the target port.
  • node_id (int) – [required] The node owning the Fibre Channel session.
  • service_id (int) – [required] The service ID of the FService owning this Fibre Channel session
  • target_wwpn (str) – [required] The WWPN of the target port involved in this session.
  • volume_access_group_id (int) – The ID of the volume access group to which the initiatorWWPN beintegers. If not in a volume access group, the value will be null.
initiator_wwpn = <type 'str'>
node_id = <type 'int'>
service_id = <type 'int'>
target_wwpn = <type 'str'>
volume_access_group_id = <type 'int'>
class solidfire.models.FipsDrivesStatusType(value)[source]

Bases: solidfire.common.model.DataObject

This specifies a node’s FIPS 140-2 compliance status.

enum_values = (u'None', u'Partial', u'Ready')
get_value()[source]
class solidfire.models.FipsErrorNodeReportErrorType(message, name)[source]

Bases: solidfire.common.model.DataObject

Parameters:
  • message (str) – [required] Error message.
  • name (str) – [required] Error name.
message = <type 'str'>
name = <type 'str'>
class solidfire.models.FipsErrorNodeReportType(error, node_id)[source]

Bases: solidfire.common.model.DataObject

Error description about why a node failed to gather FIPS information.

Parameters:
error = <class 'solidfire.models.FipsErrorNodeReportErrorType'>
node_id = <type 'int'>
class solidfire.models.FipsNodeReportType(https_enabled, fips_drives, node_id)[source]

Bases: solidfire.common.model.DataObject

FIPS related information for a node.

Parameters:
  • https_enabled (bool) – [required] FIPS https feature status.
  • fips_drives (FipsDrivesStatusType) – [required] Node’s FipsDrives capability status.
  • node_id (int) – [required] Node ID.
fips_drives = <class 'solidfire.models.FipsDrivesStatusType'>
https_enabled = <type 'bool'>
node_id = <type 'int'>
class solidfire.models.Frequency(**kwargs)[source]

Bases: solidfire.custom.models.Frequency

class solidfire.models.GetAPIResult(current_version, supported_versions)[source]

Bases: solidfire.common.model.DataObject

Parameters:
  • current_version (float) – [required]
  • supported_versions (float) – [required]
current_version = <type 'float'>
supported_versions = <type 'float[]'>
class solidfire.models.GetAccountByIDRequest(account_id)[source]

Bases: solidfire.common.model.DataObject

GetAccountByID enables you to return details about a specific account, given its accountID.

Parameters:account_id (int) – [required] Specifies the account for which details are gathered.
account_id = <type 'int'>
class solidfire.models.GetAccountByNameRequest(username)[source]

Bases: solidfire.common.model.DataObject

GetAccountByName enables you to retrieve details about a specific account, given its username.

Parameters:username (str) – [required] Username for the account.
username = <type 'str'>
class solidfire.models.GetAccountEfficiencyRequest(account_id)[source]

Bases: solidfire.common.model.DataObject

GetAccountEfficiency enables you to retrieve efficiency statistics about a volume account. This method returns efficiency information only for the account you specify as a parameter.

Parameters:account_id (int) – [required] Specifies the volume account for which efficiency statistics are returned.
account_id = <type 'int'>
class solidfire.models.GetAccountResult(account)[source]

Bases: solidfire.common.model.DataObject

Parameters:account (Account) – [required] Account details.
account = <class 'solidfire.models.Account'>
class solidfire.models.GetActiveTlsCiphersResult(mandatory_ciphers, supplemental_ciphers)[source]

Bases: solidfire.common.model.DataObject

Parameters:
  • mandatory_ciphers (str) – [required] List of mandatory TLS cipher suites for the cluster.
  • supplemental_ciphers (str) – [required] List of supplemental TLS cipher suites for the cluster.
mandatory_ciphers = <type 'str[]'>
supplemental_ciphers = <type 'str[]'>
class solidfire.models.GetAsyncResultRequest(async_handle, keep_result=None)[source]

Bases: solidfire.common.model.DataObject

You can use GetAsyncResult to retrieve the result of asynchronous method calls. Some method calls require some time to run, and might not be finished when the system sends the initial response. To obtain the status or result of the method call, use GetAsyncResult to poll the asyncHandle value returned by the method. GetAsyncResult returns the overall status of the operation (in progress, completed, or error) in a standard fashion, but the actual data returned for the operation depends on the original method call and the return data is documented with each method.

Parameters:
  • async_handle (int) – [required] A value that was returned from the original asynchronous method call.
  • keep_result (bool) – If true, GetAsyncResult does not remove the asynchronous result upon returning it, enabling future queries to that asyncHandle.
async_handle = <type 'int'>
keep_result = <type 'bool'>
class solidfire.models.GetBackupTargetRequest(backup_target_id)[source]

Bases: solidfire.common.model.DataObject

GetBackupTarget enables you to return information about a specific backup target that you have created.

Parameters:backup_target_id (int) – [required] The unique identifier assigned to the backup target.
backup_target_id = <type 'int'>
class solidfire.models.GetBackupTargetResult(backup_target)[source]

Bases: solidfire.common.model.DataObject

Parameters:backup_target (BackupTarget) – [required] Object returned for backup target.
backup_target = <class 'solidfire.models.BackupTarget'>
class solidfire.models.GetBinAssignmentPropertiesResult(properties)[source]

Bases: solidfire.common.model.DataObject

Parameters:properties (BinAssignmentProperties) – [required] Properties for current bin assignments in database.
properties = <class 'solidfire.models.BinAssignmentProperties'>
class solidfire.models.GetBootstrapConfigResult(cluster_name, node_name, nodes, version, mvip, svip)[source]

Bases: solidfire.common.model.DataObject

Parameters:
  • cluster_name (str) – [required] Name of the cluster.
  • node_name (str) – [required] Name of the node.
  • nodes (NodeWaitingToJoin) – [required] List of descriptions for each node that is actively waiting to join this cluster: compatible - Indicates if the listed node is compatible with the node the API call was executed against. name - IP address of each node. version - version of SolidFire Element software currently installed on the node.
  • version (str) – [required] Version of the SolidFire Element software currently installed.
  • mvip (str) – [required] Cluster MVIP address. This will be null if the node is not in a cluster.
  • svip (str) – [required] Cluster SVIP address. This will be null if the node is not in a cluster.
cluster_name = <type 'str'>
mvip = <type 'str'>
node_name = <type 'str'>
nodes = <class 'solidfire.models.NodeWaitingToJoin[]'>
svip = <type 'str'>
version = <type 'str'>
class solidfire.models.GetClientCertificateSignRequestResult(client_certificate_sign_request)[source]

Bases: solidfire.common.model.DataObject

Parameters:client_certificate_sign_request (str) – [required] A PEM format Base64 encoded PKCS#10 X.509 client certificate sign request.
client_certificate_sign_request = <type 'str'>
class solidfire.models.GetClusterCapacityResult(cluster_capacity)[source]

Bases: solidfire.common.model.DataObject

Parameters:cluster_capacity (ClusterCapacity) – [required]
cluster_capacity = <class 'solidfire.models.ClusterCapacity'>
class solidfire.models.GetClusterConfigResult(cluster)[source]

Bases: solidfire.common.model.DataObject

Parameters:cluster (ClusterConfig) – [required] Cluster configuration information the node uses to communicate with the cluster.
cluster = <class 'solidfire.models.ClusterConfig'>
class solidfire.models.GetClusterFullThresholdResult(block_fullness, fullness, max_metadata_over_provision_factor, metadata_fullness, slice_reserve_used_threshold_pct, stage2_aware_threshold, stage2_block_threshold_bytes, stage3_block_threshold_bytes, stage3_block_threshold_percent, stage3_metadata_threshold_percent, stage3_low_threshold, stage4_critical_threshold, stage4_block_threshold_bytes, stage5_block_threshold_bytes, sum_total_cluster_bytes, sum_total_metadata_cluster_bytes, sum_used_cluster_bytes, sum_used_metadata_cluster_bytes, stage2_metadata_threshold_bytes, stage3_metadata_threshold_bytes, stage4_metadata_threshold_bytes, stage5_metadata_threshold_bytes)[source]

Bases: solidfire.common.model.DataObject

Parameters:
  • block_fullness (str) – [required] Current computed level of block fullness of the cluster. Possible values: stage1Happy: No alerts or error conditions. stage2Aware: 3 nodes of capacity available. stage3Low: 2 nodes of capacity available. stage4Critical: 1 node of capacity available. No new volumes or clones can be created. stage5CompletelyConsumed: Completely consumed. Cluster is read-only, iSCSI connection is maintained but all writes are suspended.
  • fullness (str) – [required] Reflects the highest level of fullness between “blockFullness” and “metadataFullness”.
  • max_metadata_over_provision_factor (int) – [required] A value representative of the number of times metadata space can be over provisioned relative to the amount of space available. For example, if there was enough metadata space to store 100 TiB of volumes and this number was set to 5, then 500 TiB worth of volumes could be created.
  • metadata_fullness (str) – [required] Current computed level of metadata fullness of the cluster.
  • slice_reserve_used_threshold_pct (int) – [required] Error condition; message sent to “Alerts” if the reserved slice utilization is greater than the sliceReserveUsedThresholdPct value returned.
  • stage2_aware_threshold (int) – [required] Awareness condition: Value that is set for “Stage 2” cluster threshold level.
  • stage2_block_threshold_bytes (int) – [required] Number of bytes being used by the cluster at which a stage2 condition will exist.
  • stage3_block_threshold_bytes (int) – [required] Number of bytes being used by the cluster at which a stage3 condition will exist.
  • stage3_block_threshold_percent (int) – [required] The percent value set for stage3 of block fullness. At this percent full, a warning will be posted in the Alerts log.
  • stage3_metadata_threshold_percent (int) – [required] The percent value set for stage3 of metadata fullness. At this percent full, a warning will be posted in the Alerts log.
  • stage3_low_threshold (int) – [required] Error condition; message sent to “Alerts” that capacity on a cluster is getting low.
  • stage4_critical_threshold (int) – [required] Error condition; message sent to “Alerts” that capacity on a cluster is critically low.
  • stage4_block_threshold_bytes (int) – [required] Number of bytes being used by the cluster at which a stage4 condition will exist.
  • stage5_block_threshold_bytes (int) – [required] Number of bytes being used by the cluster at which a stage5 condition will exist.
  • sum_total_cluster_bytes (int) – [required] Physical capacity of the cluster measured in bytes.
  • sum_total_metadata_cluster_bytes (int) – [required] Total amount of space that can be used to store metadata.
  • sum_used_cluster_bytes (int) – [required] Number of bytes used on the cluster.
  • sum_used_metadata_cluster_bytes (int) – [required] Amount of space used on volume drives to store metadata.
  • stage2_metadata_threshold_bytes (int) – [required] Number of metadata bytes being used by the cluster at which a stage2 condition will exist.
  • stage3_metadata_threshold_bytes (int) – [required] Number of metadata bytes being used by the cluster at which a stage3 condition will exist.
  • stage4_metadata_threshold_bytes (int) – [required] Number of metadata bytes being used by the cluster at which a stage4 condition will exist.
  • stage5_metadata_threshold_bytes (int) – [required] Number of metadata bytes being used by the cluster at which a stage5 condition will exist.
block_fullness = <type 'str'>
fullness = <type 'str'>
max_metadata_over_provision_factor = <type 'int'>
metadata_fullness = <type 'str'>
slice_reserve_used_threshold_pct = <type 'int'>
stage2_aware_threshold = <type 'int'>
stage2_block_threshold_bytes = <type 'int'>
stage2_metadata_threshold_bytes = <type 'int'>
stage3_block_threshold_bytes = <type 'int'>
stage3_block_threshold_percent = <type 'int'>
stage3_low_threshold = <type 'int'>
stage3_metadata_threshold_bytes = <type 'int'>
stage3_metadata_threshold_percent = <type 'int'>
stage4_block_threshold_bytes = <type 'int'>
stage4_critical_threshold = <type 'int'>
stage4_metadata_threshold_bytes = <type 'int'>
stage5_block_threshold_bytes = <type 'int'>
stage5_metadata_threshold_bytes = <type 'int'>
sum_total_cluster_bytes = <type 'int'>
sum_total_metadata_cluster_bytes = <type 'int'>
sum_used_cluster_bytes = <type 'int'>
sum_used_metadata_cluster_bytes = <type 'int'>
class solidfire.models.GetClusterHardwareInfoRequest(type=None)[source]

Bases: solidfire.common.model.DataObject

You can use the GetClusterHardwareInfo method to retrieve the hardware status and information for all Fibre Channel nodes, iSCSI nodes and drives in the cluster. This generally includes details about manufacturers, vendors, versions, and other associated hardware identification information.

Parameters:type (str) – Includes only a certain type of hardware information in the response. Possible values are: drives: List only drive information in the response. nodes: List only node information in the response. all: Include both drive and node information in the response. If this parameter is omitted, a type of “all” is assumed.
type = <type 'str'>
class solidfire.models.GetClusterHardwareInfoResult(cluster_hardware_info)[source]

Bases: solidfire.common.model.DataObject

Parameters:cluster_hardware_info (ClusterHardwareInfo) – [required] Hardware information for all nodes and drives in the cluster. Each object in this output is labeled with the nodeID of the given node.
cluster_hardware_info = <class 'solidfire.models.ClusterHardwareInfo'>
class solidfire.models.GetClusterInfoResult(cluster_info)[source]

Bases: solidfire.common.model.DataObject

Parameters:cluster_info (ClusterInfo) – [required]
cluster_info = <class 'solidfire.models.ClusterInfo'>
class solidfire.models.GetClusterInterfacePreferenceRequest(name)[source]

Bases: solidfire.common.model.DataObject

Retrieves an existing cluster interface preference.

Parameters:name (str) – [required] Name of the cluster interface preference.
name = <type 'str'>
class solidfire.models.GetClusterInterfacePreferenceResult(preference)[source]

Bases: solidfire.common.model.DataObject

Parameters:preference (ClusterInterfacePreference) – [required] The cluster interface preference for the given name.
preference = <class 'solidfire.models.ClusterInterfacePreference'>
class solidfire.models.GetClusterMasterNodeIDResult(node_id)[source]

Bases: solidfire.common.model.DataObject

Parameters:node_id (int) – [required] ID of the master node.
node_id = <type 'int'>
class solidfire.models.GetClusterSshInfoResult(enabled, time_remaining, nodes)[source]

Bases: solidfire.common.model.DataObject

Parameters:
  • enabled (bool) – [required] Status of SSH on the cluster.
  • time_remaining (str) – [required] Time remaining until SSH is disable on the cluster.
  • nodes (NodeSshInfo) – [required] Time remaining until SSH is disable on the cluster.
enabled = <type 'bool'>
nodes = <class 'solidfire.models.NodeSshInfo[]'>
time_remaining = <type 'str'>
class solidfire.models.GetClusterStateRequest(force)[source]

Bases: solidfire.common.model.DataObject

The GetClusterState API method enables you to indicate if a node is part of a cluster or not. The three states are: Available: Node has not been configured with a cluster name. Pending: Node is pending for a specific named cluster and can be added. Active: Node is an active member of a cluster and may not be added to another cluster. Note: This method is available only through the per-node API endpoint 5.0 or later.

Parameters:force (bool) – [required] To run this command, the force parameter must be set to true.
force = <type 'bool'>
class solidfire.models.GetClusterStateResult(nodes=None, cluster=None, state=None)[source]

Bases: solidfire.common.model.DataObject

Parameters:
  • nodes (NodeStateResult) – Array of NodeStateResult objects for each node in the cluster.
  • cluster (str) –
  • state (str) –
cluster = <type 'str'>
nodes = <class 'solidfire.models.NodeStateResult[]'>
state = <type 'str'>
class solidfire.models.GetClusterStatsResult(cluster_stats)[source]

Bases: solidfire.common.model.DataObject

Parameters:cluster_stats (ClusterStats) – [required]
cluster_stats = <class 'solidfire.models.ClusterStats'>
class solidfire.models.GetClusterStructureResult(accounts, cluster_admins, cluster_info, default_qos, features, initiators, ldap_configuration, ntp, qos_policies, remote_hosts, schedules, snmp, virtual_networks, volume_access_group_lun_assignments, volume_access_groups, volumes, tls_ciphers=None, storage_containers=None, snap_mirror_endpoints=None)[source]

Bases: solidfire.common.model.DataObject

Parameters:
accounts = <class 'solidfire.models.Account[]'>
cluster_admins = <class 'solidfire.models.ClusterAdmin[]'>
cluster_info = <class 'solidfire.models.ClusterInfo'>
default_qos = <class 'solidfire.models.VolumeQOS'>
features = <class 'solidfire.models.FeatureObject[]'>
initiators = <class 'solidfire.models.Initiator[]'>
ldap_configuration = <class 'solidfire.models.LdapConfiguration'>
ntp = <class 'solidfire.models.GetNtpInfoResult'>
qos_policies = <class 'solidfire.models.QoSPolicy[]'>
remote_hosts = <class 'solidfire.models.LoggingServer[]'>
schedules = <class 'solidfire.models.ScheduleObject[]'>
snap_mirror_endpoints = <class 'solidfire.models.SnapMirrorEndpoint[]'>
snmp = <class 'solidfire.models.GetSnmpInfoResult'>
storage_containers = <class 'solidfire.models.StorageContainer[]'>
tls_ciphers = <class 'solidfire.models.GetActiveTlsCiphersResult'>
virtual_networks = <class 'solidfire.models.VirtualNetwork[]'>
volume_access_group_lun_assignments = <class 'solidfire.models.VolumeAccessGroupLunAssignments[]'>
volume_access_groups = <class 'solidfire.models.VolumeAccessGroup[]'>
volumes = <class 'solidfire.models.Volume[]'>
class solidfire.models.GetClusterVersionInfoResult(cluster_apiversion, cluster_version, cluster_version_info, software_version_info)[source]

Bases: solidfire.common.model.DataObject

Parameters:
  • cluster_apiversion (str) – [required]
  • cluster_version (str) – [required]
  • cluster_version_info (ClusterVersionInfo) – [required]
  • software_version_info (SoftwareVersionInfo) – [required]
cluster_apiversion = <type 'str'>
cluster_version = <type 'str'>
cluster_version_info = <class 'solidfire.models.ClusterVersionInfo[]'>
software_version_info = <class 'solidfire.models.SoftwareVersionInfo'>
class solidfire.models.GetConfigResult(config)[source]

Bases: solidfire.common.model.DataObject

Parameters:config (Config) – [required] The details of the cluster. Values returned in “config”: cluster- Cluster information that identifies how the node communicates with the cluster it is associated with. (Object) network - Network information for bonding and Ethernet connections. (Object)
config = <class 'solidfire.models.Config'>
class solidfire.models.GetCurrentClusterAdminResult(cluster_admin)[source]

Bases: solidfire.common.model.DataObject

Parameters:cluster_admin (ClusterAdmin) – [required] Information about the calling ClusterAdmin. In case the returned ClusterAdmin object has authMethod value of Ldap or Idp: The access field may contain data aggregated from multiple LdapAdmins or IdpAdmins. If this is the case, the clusterAdminId will be set to -1 to indicate that there may not be a unique, 1:1 mapping of the calling ClusterAdmin with a ClusterAdmin on the cluster.
cluster_admin = <class 'solidfire.models.ClusterAdmin'>
class solidfire.models.GetDriveConfigResult(drive_config)[source]

Bases: solidfire.common.model.DataObject

Parameters:drive_config (DrivesConfigInfo) – [required] Configuration information for the drives that are connected to the cluster
drive_config = <class 'solidfire.models.DrivesConfigInfo'>
class solidfire.models.GetDriveHardwareInfoRequest(drive_id)[source]

Bases: solidfire.common.model.DataObject

GetDriveHardwareInfo returns all the hardware information for the given drive. This generally includes details about manufacturers, vendors, versions, and other associated hardware identification information.

Parameters:drive_id (int) – [required] DriveID for the drive information requested. You can get DriveIDs by using the ListDrives method.
drive_id = <type 'int'>
class solidfire.models.GetDriveHardwareInfoResult(drive_hardware_info)[source]

Bases: solidfire.common.model.DataObject

Parameters:drive_hardware_info (DriveHardwareInfo) – [required]
drive_hardware_info = <class 'solidfire.models.DriveHardwareInfo'>
class solidfire.models.GetDriveStatsRequest(drive_id)[source]

Bases: solidfire.common.model.DataObject

GetDriveStats returns high-level activity measurements for a single drive. Values are cumulative from the addition of the drive to the cluster. Some values are specific to block drives. You might not obtain statistical data for both block and metadata drives when you run this method.

Parameters:drive_id (int) – [required] Specifies the drive for which statistics are gathered.
drive_id = <type 'int'>
class solidfire.models.GetDriveStatsResult(drive_stats)[source]

Bases: solidfire.common.model.DataObject

Parameters:drive_stats (DriveStats) – [required]
drive_stats = <class 'solidfire.models.DriveStats'>
class solidfire.models.GetEfficiencyResult(timestamp, missing_volumes, compression=None, deduplication=None, thin_provisioning=None)[source]

Bases: solidfire.common.model.DataObject

Parameters:
  • compression (float) – The amount of space being saved by compressing data on a single volume. Stated as a ratio where “1” means data has been stored without being compressed.
  • deduplication (float) – The amount of space being saved on a single volume by not duplicating data. Stated as a ratio.
  • thin_provisioning (float) – The ratio of space used to the amount of space allocated for storing data. Stated as a ratio.
  • timestamp (str) – [required] The last time efficiency data was collected after Garbage Collection (GC). ISO 8601 data string.
  • missing_volumes (int) – [required] The volumes that could not be queried for efficiency data. Missing volumes can be caused by GC being less than hour old, temporary network loss or restarted services since the GC cycle.
compression = <type 'float'>
deduplication = <type 'float'>
missing_volumes = <type 'int[]'>
thin_provisioning = <type 'float'>
timestamp = <type 'str'>
class solidfire.models.GetFeatureStatusRequest(feature=None)[source]

Bases: solidfire.common.model.DataObject

GetFeatureStatus enables you to retrieve the status of a cluster feature.

Parameters:feature (str) – Specifies the feature for which the status is returned. Valid values are: vvols: Retrieve status for the NetApp SolidFire VVols cluster feature. FipsDrives: Retrieve status for the FIPS 140-2 drive encryption feature. Fips: Retrieve status for the FIPS 140-2 encryption for HTTPS communication feature. SnapMirror: Retrieve status for the SnapMirror replication cluster feature.
feature = <type 'str'>
class solidfire.models.GetFeatureStatusResult(features)[source]

Bases: solidfire.common.model.DataObject

Parameters:features (FeatureObject) – [required] An array of feature objects indicating the feature name and its status.
features = <class 'solidfire.models.FeatureObject[]'>
class solidfire.models.GetFipsReportResult(nodes, error_nodes)[source]

Bases: solidfire.common.model.DataObject

An array of objects, one from each node in the cluster, indicating FIPS information.

Parameters:
error_nodes = <class 'solidfire.models.FipsErrorNodeReportType[]'>
nodes = <class 'solidfire.models.FipsNodeReportType[]'>
class solidfire.models.GetHardwareConfigResult(hardware_config)[source]

Bases: solidfire.common.model.DataObject

Parameters:hardware_config (dict) – [required] List of hardware information and current settings.
hardware_config = <type 'dict'>
class solidfire.models.GetHardwareInfoResult(hardware_info)[source]

Bases: solidfire.common.model.DataObject

Parameters:hardware_info (dict) – [required] Hardware information for this node.
hardware_info = <type 'dict'>
class solidfire.models.GetIdpAuthenticationStateResult(enabled)[source]

Bases: solidfire.common.model.DataObject

Return information regarding the state of authentication using third party Identity Providers

Parameters:enabled (bool) – [required] Whether third party Identity Provider Authentication is enabled.
enabled = <type 'bool'>
class solidfire.models.GetIpmiConfigNodesResult(node_id, result)[source]

Bases: solidfire.common.model.DataObject

Parameters:
  • node_id (int) – [required]
  • result (dict) – [required]
node_id = <type 'int'>
result = <type 'dict'>
class solidfire.models.GetIpmiConfigRequest(chassis_type=None)[source]

Bases: solidfire.common.model.DataObject

GetIpmiConfig enables you to retrieve hardware sensor information from sensors that are in your node.

Parameters:chassis_type (str) – Displays information for each node chassis type. Valid values are: all: Returns sensor information for each chassis type. {chassis type}: Returns sensor information for a specified chassis type.
chassis_type = <type 'str'>
class solidfire.models.GetIpmiConfigResult(nodes)[source]

Bases: solidfire.common.model.DataObject

Parameters:nodes (GetIpmiConfigNodesResult) – [required]
nodes = <class 'solidfire.models.GetIpmiConfigNodesResult[]'>
class solidfire.models.GetIpmiInfoResult(ipmi_info)[source]

Bases: solidfire.common.model.DataObject

Parameters:ipmi_info (IpmiInfo) – [required]
ipmi_info = <class 'solidfire.models.IpmiInfo'>
class solidfire.models.GetKeyProviderKmipRequest(key_provider_id)[source]

Bases: solidfire.common.model.DataObject

Returns the specified KMIP (Key Management Interoperability Protocol) Key Provider object.

Parameters:key_provider_id (int) – [required] The ID of the KMIP Key Provider object to return.
key_provider_id = <type 'int'>
class solidfire.models.GetKeyProviderKmipResult(kmip_key_provider)[source]

Bases: solidfire.common.model.DataObject

Parameters:kmip_key_provider (KeyProviderKmip) – [required] A KMIP (Key Management Interoperability Protocol) Key Provider which was created previously via CreateKeyProviderKmip.
kmip_key_provider = <class 'solidfire.models.KeyProviderKmip'>
class solidfire.models.GetKeyServerKmipRequest(key_server_id)[source]

Bases: solidfire.common.model.DataObject

Returns the specified KMIP (Key Management Interoperability Protocol) Key Server object.

Parameters:key_server_id (int) – [required] The ID of the KMIP Key Server object to return.
key_server_id = <type 'int'>
class solidfire.models.GetKeyServerKmipResult(kmip_key_server)[source]

Bases: solidfire.common.model.DataObject

Parameters:kmip_key_server (KeyServerKmip) – [required] A KMIP (Key Management Interoperability Protocol) Key Server which was created previously via CreateKeyServerKmip.
kmip_key_server = <class 'solidfire.models.KeyServerKmip'>
class solidfire.models.GetLdapConfigurationResult(ldap_configuration)[source]

Bases: solidfire.common.model.DataObject

Parameters:ldap_configuration (LdapConfiguration) – [required] List of the current LDAP configuration settings. This API call will not return the plain text of the search account password. Note: If LDAP authentication is currently disabled, all the returned settings will be empty with the exception of “authType”, and “groupSearchType” which are set to “SearchAndBind” and “ActiveDirectory” respectively.
ldap_configuration = <class 'solidfire.models.LdapConfiguration'>
class solidfire.models.GetLicenseKeyResult(serial_number, order_number)[source]

Bases: solidfire.common.model.DataObject

Parameters:
  • serial_number (str) – [required] The Serial Number For the Cluster.
  • order_number (str) – [required] The Sales Order Number.
order_number = <type 'str'>
serial_number = <type 'str'>
class solidfire.models.GetLimitsResult(account_count_max, account_name_length_max, account_name_length_min, bulk_volume_jobs_per_node_max, bulk_volume_jobs_per_volume_max, clone_jobs_per_volume_max, cluster_pairs_count_max, initiator_name_length_max, initiator_count_max, initiators_per_volume_access_group_count_max, iscsi_sessions_from_fibre_channel_nodes_max, qos_policy_count_max, secret_length_max, schedule_name_length_max, secret_length_min, snapshot_name_length_max, snapshots_per_volume_max, volume_access_group_count_max, volume_access_group_lun_max, volume_access_group_name_length_max, volume_access_group_name_length_min, volume_access_groups_per_initiator_count_max, volume_access_groups_per_volume_count_max, initiator_alias_length_max, volume_burst_iopsmax, volume_burst_iopsmin, volume_count_max, volume_max_iopsmax, volume_max_iopsmin, volume_min_iopsmax, volume_min_iopsmin, volume_name_length_max, volume_name_length_min, volume_size_max, volume_size_min, volumes_per_account_count_max, volumes_per_group_snapshot_max, volumes_per_volume_access_group_count_max, cluster_admin_account_max=None, fibre_channel_volume_access_max=None, virtual_volumes_per_account_count_max=None, virtual_volume_count_max=None)[source]

Bases: solidfire.common.model.DataObject

Limits for the cluster

Parameters:
  • account_count_max (int) – [required]
  • account_name_length_max (int) – [required]
  • account_name_length_min (int) – [required]
  • bulk_volume_jobs_per_node_max (int) – [required]
  • bulk_volume_jobs_per_volume_max (int) – [required]
  • clone_jobs_per_volume_max (int) – [required]
  • cluster_pairs_count_max (int) – [required]
  • initiator_name_length_max (int) – [required]
  • initiator_count_max (int) – [required]
  • initiators_per_volume_access_group_count_max (int) – [required]
  • iscsi_sessions_from_fibre_channel_nodes_max (int) – [required]
  • qos_policy_count_max (int) – [required]
  • secret_length_max (int) – [required]
  • schedule_name_length_max (int) – [required]
  • secret_length_min (int) – [required]
  • snapshot_name_length_max (int) – [required]
  • snapshots_per_volume_max (int) – [required]
  • volume_access_group_count_max (int) – [required]
  • volume_access_group_lun_max (int) – [required]
  • volume_access_group_name_length_max (int) – [required]
  • volume_access_group_name_length_min (int) – [required]
  • volume_access_groups_per_initiator_count_max (int) – [required]
  • volume_access_groups_per_volume_count_max (int) – [required]
  • initiator_alias_length_max (int) – [required]
  • volume_burst_iopsmax (int) – [required]
  • volume_burst_iopsmin (int) – [required]
  • volume_count_max (int) – [required]
  • volume_max_iopsmax (int) – [required]
  • volume_max_iopsmin (int) – [required]
  • volume_min_iopsmax (int) – [required]
  • volume_min_iopsmin (int) – [required]
  • volume_name_length_max (int) – [required]
  • volume_name_length_min (int) – [required]
  • volume_size_max (int) – [required]
  • volume_size_min (int) – [required]
  • volumes_per_account_count_max (int) – [required]
  • volumes_per_group_snapshot_max (int) – [required]
  • volumes_per_volume_access_group_count_max (int) – [required]
  • cluster_admin_account_max (int) –
  • fibre_channel_volume_access_max (int) –
  • virtual_volumes_per_account_count_max (int) –
  • virtual_volume_count_max (int) –
account_count_max = <type 'int'>
account_name_length_max = <type 'int'>
account_name_length_min = <type 'int'>
bulk_volume_jobs_per_node_max = <type 'int'>
bulk_volume_jobs_per_volume_max = <type 'int'>
clone_jobs_per_volume_max = <type 'int'>
cluster_admin_account_max = <type 'int'>
cluster_pairs_count_max = <type 'int'>
fibre_channel_volume_access_max = <type 'int'>
initiator_alias_length_max = <type 'int'>
initiator_count_max = <type 'int'>
initiator_name_length_max = <type 'int'>
initiators_per_volume_access_group_count_max = <type 'int'>
iscsi_sessions_from_fibre_channel_nodes_max = <type 'int'>
qos_policy_count_max = <type 'int'>
schedule_name_length_max = <type 'int'>
secret_length_max = <type 'int'>
secret_length_min = <type 'int'>
snapshot_name_length_max = <type 'int'>
snapshots_per_volume_max = <type 'int'>
virtual_volume_count_max = <type 'int'>
virtual_volumes_per_account_count_max = <type 'int'>
volume_access_group_count_max = <type 'int'>
volume_access_group_lun_max = <type 'int'>
volume_access_group_name_length_max = <type 'int'>
volume_access_group_name_length_min = <type 'int'>
volume_access_groups_per_initiator_count_max = <type 'int'>
volume_access_groups_per_volume_count_max = <type 'int'>
volume_burst_iopsmax = <type 'int'>
volume_burst_iopsmin = <type 'int'>
volume_count_max = <type 'int'>
volume_max_iopsmax = <type 'int'>
volume_max_iopsmin = <type 'int'>
volume_min_iopsmax = <type 'int'>
volume_min_iopsmin = <type 'int'>
volume_name_length_max = <type 'int'>
volume_name_length_min = <type 'int'>
volume_size_max = <type 'int'>
volume_size_min = <type 'int'>
volumes_per_account_count_max = <type 'int'>
volumes_per_group_snapshot_max = <type 'int'>
volumes_per_volume_access_group_count_max = <type 'int'>
class solidfire.models.GetLldpConfigResult(lldp_config)[source]

Bases: solidfire.common.model.DataObject

This result represents the current LLDP configuration state

Parameters:lldp_config (LldpConfig) – [required] Enable the LLDP service
lldp_config = <class 'solidfire.models.LldpConfig'>
class solidfire.models.GetLoginBannerResult(login_banner)[source]

Bases: solidfire.common.model.DataObject

Parameters:login_banner (LoginBanner) – [required]
login_banner = <class 'solidfire.models.LoginBanner'>
class solidfire.models.GetLoginSessionInfoResult(login_session_info)[source]

Bases: solidfire.common.model.DataObject

Parameters:login_session_info (LoginSessionInfo) – [required] The authentication expiration period. Formatted in H:mm:ss. For example: 1:30:00, 20:00, 5:00. All leading zeros and colons are removed regardless of the format the timeout was entered. Objects returned are: timeout - The time, in minutes, when this session will timeout and expire.
login_session_info = <class 'solidfire.models.LoginSessionInfo'>
class solidfire.models.GetNetworkConfigResult(network, network_interfaces=None)[source]

Bases: solidfire.common.model.DataObject

Parameters:
network = <class 'solidfire.models.Network'>
network_interfaces = <class 'solidfire.models.NetworkConfig[]'>
class solidfire.models.GetNodeActiveTlsCiphersResult(mandatory_ciphers, supplemental_ciphers)[source]

Bases: solidfire.common.model.DataObject

Parameters:
  • mandatory_ciphers (str) – [required] List of mandatory TLS cipher suites for the node.
  • supplemental_ciphers (str) – [required] List of supplemental TLS cipher suites for the node.
mandatory_ciphers = <type 'str[]'>
supplemental_ciphers = <type 'str[]'>
class solidfire.models.GetNodeFipsDrivesReportResult(fips_drives)[source]

Bases: solidfire.common.model.DataObject

This specifies a node’s FIPS 140-2 drive capability status

Parameters:fips_drives (FipsDrivesStatusType) – [required] Node’s FipsDrives capability status.
fips_drives = <class 'solidfire.models.FipsDrivesStatusType'>
class solidfire.models.GetNodeHardwareInfoRequest(node_id)[source]

Bases: solidfire.common.model.DataObject

GetNodeHardwareInfo enables you to return all the hardware information and status for the node specified. This generally includes details about manufacturers, vendors, versions, and other associated hardware identification information.

Parameters:node_id (int) – [required] The ID of the node for which hardware information is being requested. Information about a Fibre Channel node is returned if a Fibre Channel node is specified.
node_id = <type 'int'>
class solidfire.models.GetNodeHardwareInfoResult(node_hardware_info)[source]

Bases: solidfire.common.model.DataObject

Parameters:node_hardware_info (dict) – [required] Hardware information for the specified nodeID.
node_hardware_info = <type 'dict'>
class solidfire.models.GetNodeSSLCertificateResult(certificate, details)[source]

Bases: solidfire.common.model.DataObject

Parameters:
  • certificate (str) – [required] The full PEM-encoded test of the certificate.
  • details (dict) – [required] The decoded information of the certificate.
certificate = <type 'str'>
details = <type 'dict'>
class solidfire.models.GetNodeStatsRequest(node_id)[source]

Bases: solidfire.common.model.DataObject

GetNodeStats enables you to retrieve the high-level activity measurements for a single node.

Parameters:node_id (int) – [required] Specifies the node for which statistics are gathered.
node_id = <type 'int'>
class solidfire.models.GetNodeStatsResult(node_stats)[source]

Bases: solidfire.common.model.DataObject

Parameters:node_stats (NodeStatsInfo) – [required] Node activity information.
node_stats = <class 'solidfire.models.NodeStatsInfo'>
class solidfire.models.GetNodeSupportedTlsCiphersResult(mandatory_ciphers, default_supplemental_ciphers, supported_supplemental_ciphers)[source]

Bases: solidfire.common.model.DataObject

Parameters:
  • mandatory_ciphers (str) – [required] List of mandatory TLS cipher suites for the node. Mandatory ciphers are those ciphers which will always be active on the node.
  • default_supplemental_ciphers (str) – [required] List of default supplemental TLS cipher suites for the node. The supplemental ciphers will be restored to this list when the ResetNodeSupplementalTlsCiphers command is run.
  • supported_supplemental_ciphers (str) – [required] List of available supplemental TLS cipher suites which can be configured with the SetNodeSupplementalTlsCiphers command.
default_supplemental_ciphers = <type 'str[]'>
mandatory_ciphers = <type 'str[]'>
supported_supplemental_ciphers = <type 'str[]'>
class solidfire.models.GetNtpInfoResult(broadcastclient, servers)[source]

Bases: solidfire.common.model.DataObject

Parameters:
  • broadcastclient (bool) – [required] Indicates whether or not the nodes in the cluster are listening for broadcast NTP messages. Possible values: true false
  • servers (str) – [required] List of NTP servers.
broadcastclient = <type 'bool'>
servers = <type 'str[]'>
class solidfire.models.GetNvramInfoRequest(force=None)[source]

Bases: solidfire.common.model.DataObject

GetNvramInfo enables you to retrieve information from each node about the NVRAM card.

Parameters:force (bool) – Required parameter to successfully run on all nodes in the cluster.
force = <type 'bool'>
class solidfire.models.GetNvramInfoResult(nvram_info)[source]

Bases: solidfire.common.model.DataObject

Parameters:nvram_info (NvramInfo) – [required] Arrays of events and errors detected on the NVRAM card.
nvram_info = <class 'solidfire.models.NvramInfo'>
class solidfire.models.GetOntapVersionInfoRequest(snap_mirror_endpoint_id=None)[source]

Bases: solidfire.common.model.DataObject

The SolidFire Element OS web UI uses GetOntapVersionInfo to get information about API version support from the ONTAP cluster in a SnapMirror relationship.

Parameters:snap_mirror_endpoint_id (int) – If provided, the system lists the version information from the endpoint with the specified snapMirrorEndpointID. If not provided, the system lists the version information of all known SnapMirror endpoints.
snap_mirror_endpoint_id = <type 'int'>
class solidfire.models.GetOntapVersionInfoResult(ontap_version_info)[source]

Bases: solidfire.common.model.DataObject

Parameters:ontap_version_info (OntapVersionInfo) – [required] The software version information of the ONTAP endpoint.
ontap_version_info = <class 'solidfire.models.OntapVersionInfo[]'>
class solidfire.models.GetOriginNode(node_id, result)[source]

Bases: solidfire.common.model.DataObject

Parameters:
node_id = <type 'int'>
result = <class 'solidfire.models.GetOriginNodeResult'>
class solidfire.models.GetOriginNodeResult(origin=None)[source]

Bases: solidfire.common.model.DataObject

Parameters:origin (Origin) –
origin = <class 'solidfire.models.Origin'>
class solidfire.models.GetOriginResult(nodes)[source]

Bases: solidfire.common.model.DataObject

Parameters:nodes (GetOriginNode) – [required]
nodes = <class 'solidfire.models.GetOriginNode[]'>
class solidfire.models.GetPendingOperationResult(pending_operation)[source]

Bases: solidfire.common.model.DataObject

Parameters:pending_operation (PendingOperation) – [required]
pending_operation = <class 'solidfire.models.PendingOperation'>
class solidfire.models.GetProtectionDomainLayoutResult(protection_domain_layout)[source]

Bases: solidfire.common.model.DataObject

Parameters:protection_domain_layout (NodeProtectionDomains) – [required] How all of the nodes are grouped into different ProtectionDomains.
protection_domain_layout = <class 'solidfire.models.NodeProtectionDomains[]'>
class solidfire.models.GetProtectionSchemesResult(protection_schemes)[source]

Bases: solidfire.common.model.DataObject

Parameters:protection_schemes (dict) – [required] The available protection schemes
protection_schemes = <type 'dict'>
class solidfire.models.GetQoSPolicyRequest(qos_policy_id)[source]

Bases: solidfire.common.model.DataObject

You can use the GetQoSPolicy method to get details about a specific QoSPolicy from the system.

Parameters:qos_policy_id (int) – [required] The ID of the policy to be retrieved.
qos_policy_id = <type 'int'>
class solidfire.models.GetQoSPolicyResult(qos_policy)[source]

Bases: solidfire.common.model.DataObject

Parameters:qos_policy (QoSPolicy) – [required] Details of the requested QoS policy.
qos_policy = <class 'solidfire.models.QoSPolicy'>
class solidfire.models.GetRemoteLoggingHostsResult(remote_hosts)[source]

Bases: solidfire.common.model.DataObject

Parameters:remote_hosts (LoggingServer) – [required] List of hosts to forward logging information to.
remote_hosts = <class 'solidfire.models.LoggingServer[]'>
class solidfire.models.GetSSLCertificateResult(certificate, details)[source]

Bases: solidfire.common.model.DataObject

Parameters:
  • certificate (str) – [required] The full PEM-encoded test of the certificate.
  • details (dict) – [required] The decoded information of the certificate.
certificate = <type 'str'>
details = <type 'dict'>
class solidfire.models.GetScheduleRequest(schedule_id)[source]

Bases: solidfire.common.model.DataObject

You can use the GetSchedule method to retrieve information about a scheduled snapshot. You can see information about a specific schedule if there are many snapshot schedules in the system. You also retrieve information about more than one schedule with this method by specifying additional scheduleIDs in the parameter.

Parameters:schedule_id (int) – [required] Specifies the unique ID of the schedule or multiple schedules to display.
schedule_id = <type 'int'>
class solidfire.models.GetScheduleResult(schedule)[source]

Bases: solidfire.common.model.DataObject

Parameters:schedule (Schedule) – [required] The schedule attributes.
schedule = <class 'solidfire.models.Schedule'>
class solidfire.models.GetSnapMirrorClusterIdentityRequest(snap_mirror_endpoint_id=None)[source]

Bases: solidfire.common.model.DataObject

The SolidFire Element OS web UI uses GetSnapMirrorClusterIdentity to get identity information about the ONTAP cluster.

Parameters:snap_mirror_endpoint_id (int) – If provided, the system lists the cluster identity of the endpoint with the specified snapMirrorEndpointID. If not provided, the system lists the cluster identity of all known SnapMirror endpoints.
snap_mirror_endpoint_id = <type 'int'>
class solidfire.models.GetSnapMirrorClusterIdentityResult(snap_mirror_cluster_identity)[source]

Bases: solidfire.common.model.DataObject

Parameters:snap_mirror_cluster_identity (SnapMirrorClusterIdentity) – [required] A list of cluster identities of SnapMirror endpoints.
snap_mirror_cluster_identity = <class 'solidfire.models.SnapMirrorClusterIdentity[]'>
class solidfire.models.GetSnmpACLResult(networks=None, usm_users=None)[source]

Bases: solidfire.common.model.DataObject

Parameters:
  • networks (SnmpNetwork) – List of networks and what type of access they have to the SNMP servers running on the cluster nodes. Present if SNMP v3 is disabled.
  • usm_users (SnmpV3UsmUser) – List of users and the type of access they have to the SNMP servers running on the cluster nodes. Present if SNMP v3 is enabled.
networks = <class 'solidfire.models.SnmpNetwork[]'>
usm_users = <class 'solidfire.models.SnmpV3UsmUser[]'>
class solidfire.models.GetSnmpInfoResult(enabled, snmp_v3_enabled, networks=None, usm_users=None)[source]

Bases: solidfire.common.model.DataObject

Parameters:
  • networks (SnmpNetwork) – List of networks and access types enabled for SNMP. Note: “networks” will only be present if SNMP V3 is disabled.
  • enabled (bool) – [required] If the nodes in the cluster are configured for SNMP.
  • snmp_v3_enabled (bool) – [required] If the nodes in the cluster are configured for SNMP v3.
  • usm_users (SnmpV3UsmUser) – If SNMP v3 is enabled, the values returned is a list of user access parameters for SNMP information from the cluster. This will be returned instead of the “networks” parameter.
enabled = <type 'bool'>
networks = <class 'solidfire.models.SnmpNetwork[]'>
snmp_v3_enabled = <type 'bool'>
usm_users = <class 'solidfire.models.SnmpV3UsmUser[]'>
class solidfire.models.GetSnmpStateResult(enabled, snmp_v3_enabled)[source]

Bases: solidfire.common.model.DataObject

Parameters:
  • enabled (bool) – [required] If the nodes in the cluster are configured for SNMP.
  • snmp_v3_enabled (bool) – [required] If the node in the cluster is configured for SNMP v3.
enabled = <type 'bool'>
snmp_v3_enabled = <type 'bool'>
class solidfire.models.GetSnmpTrapInfoResult(trap_recipients, cluster_fault_traps_enabled, cluster_fault_resolved_traps_enabled, cluster_event_traps_enabled)[source]

Bases: solidfire.common.model.DataObject

Parameters:
  • trap_recipients (SnmpTrapRecipient) – [required] List of hosts that are to receive the traps generated by the cluster.
  • cluster_fault_traps_enabled (bool) – [required] If “true”, when a cluster fault is logged a corresponding solidFireClusterFaultNotification is sent to the configured list of trap recipients.
  • cluster_fault_resolved_traps_enabled (bool) – [required] If “true”, when a cluster fault is logged a corresponding solidFireClusterFaultResolvedNotification is sent to the configured list of trap recipients.
  • cluster_event_traps_enabled (bool) – [required] If “true”, when a cluster fault is logged a corresponding solidFireClusterEventNotification is sent to the configured list of trap recipients.
cluster_event_traps_enabled = <type 'bool'>
cluster_fault_resolved_traps_enabled = <type 'bool'>
cluster_fault_traps_enabled = <type 'bool'>
trap_recipients = <class 'solidfire.models.SnmpTrapRecipient[]'>
class solidfire.models.GetSshInfoResult(enabled)[source]

Bases: solidfire.common.model.DataObject

Parameters:enabled (bool) – [required] Node SSH status.
enabled = <type 'bool'>
class solidfire.models.GetStorageContainerEfficiencyRequest(storage_container_id)[source]

Bases: solidfire.common.model.DataObject

GetStorageContainerEfficiency enables you to retrieve efficiency information about a virtual volume storage container.

Parameters:storage_container_id (UUID) – [required] The ID of the storage container for which to retrieve efficiency information.
storage_container_id = <class 'uuid.UUID'>
class solidfire.models.GetStorageContainerEfficiencyResult(compression, deduplication, missing_volumes, thin_provisioning, timestamp)[source]

Bases: solidfire.common.model.DataObject

Parameters:
  • compression (float) – [required]
  • deduplication (float) – [required]
  • missing_volumes (int) – [required] The volumes that could not be queried for efficiency data. Missing volumes can be caused by the Garbage Collection (GC) cycle being less than an hour old, temporary loss of network connectivity, or restarted services since the GC cycle.
  • thin_provisioning (float) – [required]
  • timestamp (str) – [required] The last time efficiency data was collected after Garbage Collection (GC).
compression = <type 'float'>
deduplication = <type 'float'>
missing_volumes = <type 'int[]'>
thin_provisioning = <type 'float'>
timestamp = <type 'str'>
class solidfire.models.GetSupportedTlsCiphersResult(mandatory_ciphers, default_supplemental_ciphers, supported_supplemental_ciphers)[source]

Bases: solidfire.common.model.DataObject

Parameters:
  • mandatory_ciphers (str) – [required] List of mandatory TLS cipher suites for the cluster. Mandatory ciphers are those ciphers which will always be active on the cluster.
  • default_supplemental_ciphers (str) – [required] List of default supplemental TLS cipher suites for the cluster. The supplemental ciphers will be restored to this list when the ResetSupplementalTlsCiphers command is run.
  • supported_supplemental_ciphers (str) – [required] List of available supplemental TLS cipher suites which can be configured with the SetSupplementalTlsCiphers command.
default_supplemental_ciphers = <type 'str[]'>
mandatory_ciphers = <type 'str[]'>
supported_supplemental_ciphers = <type 'str[]'>
class solidfire.models.GetSystemStatusResult(reboot_required)[source]

Bases: solidfire.common.model.DataObject

Parameters:reboot_required (bool) – [required]
reboot_required = <type 'bool'>
class solidfire.models.GetVirtualVolumeCountResult(count)[source]

Bases: solidfire.common.model.DataObject

Parameters:count (int) – [required] The number of virtual volumes currently in the system.
count = <type 'int'>
class solidfire.models.GetVolumeAccessGroupEfficiencyRequest(volume_access_group_id)[source]

Bases: solidfire.common.model.DataObject

GetVolumeAccessGroupEfficiency enables you to retrieve efficiency information about a volume access group. Only the volume access group you provide as the parameter in this API method is used to compute the capacity.

Parameters:volume_access_group_id (int) – [required] The volume access group for which capacity is computed.
volume_access_group_id = <type 'int'>
class solidfire.models.GetVolumeAccessGroupLunAssignmentsRequest(volume_access_group_id)[source]

Bases: solidfire.common.model.DataObject

The GetVolumeAccessGroupLunAssignments method enables you to retrieve details on LUN mappings of a specified volume access group.

Parameters:volume_access_group_id (int) – [required] The unique volume access group ID used to return information.
volume_access_group_id = <type 'int'>
class solidfire.models.GetVolumeAccessGroupLunAssignmentsResult(volume_access_group_lun_assignments)[source]

Bases: solidfire.common.model.DataObject

Parameters:volume_access_group_lun_assignments (VolumeAccessGroupLunAssignments) – [required] List of all physical Fibre Channel ports, or a port for a single node.
volume_access_group_lun_assignments = <class 'solidfire.models.VolumeAccessGroupLunAssignments'>
class solidfire.models.GetVolumeCountResult(count)[source]

Bases: solidfire.common.model.DataObject

Parameters:count (int) – [required] The number of volumes currently in the system.
count = <type 'int'>
class solidfire.models.GetVolumeEfficiencyRequest(volume_id)[source]

Bases: solidfire.common.model.DataObject

GetVolumeEfficiency enables you to retrieve information about a volume. Only the volume you give as a parameter in this API method is used to compute the capacity.

Parameters:volume_id (int) – [required] Specifies the volume for which capacity is computed.
volume_id = <type 'int'>
class solidfire.models.GetVolumeEfficiencyResult(deduplication, missing_volumes, thin_provisioning, timestamp, compression=None)[source]

Bases: solidfire.common.model.DataObject

Parameters:
  • compression (float) – The amount of space being saved by compressing data on a single volume. Stated as a ratio where “1” means data has been stored without being compressed.
  • deduplication (float) – [required] The amount of space being saved on a single volume by not duplicating data. Stated as a ratio.
  • missing_volumes (int) – [required] The volumes that could not be queried for efficiency data. Missing volumes can be caused by GC being less than hour old, temporary network loss or restarted services since the GC cycle.
  • thin_provisioning (float) – [required] The ratio of space used to the amount of space allocated for storing data. Stated as a ratio.
  • timestamp (str) – [required] The last time efficiency data was collected after Garbage Collection (GC).
compression = <type 'float'>
deduplication = <type 'float'>
missing_volumes = <type 'int[]'>
thin_provisioning = <type 'float'>
timestamp = <type 'str'>
class solidfire.models.GetVolumeStatsRequest(volume_id)[source]

Bases: solidfire.common.model.DataObject

GetVolumeStats enables you to retrieve high-level activity measurements for a single volume. Values are cumulative from the creation of the volume.

Parameters:volume_id (int) – [required] Specifies the volume for which statistics are gathered.
volume_id = <type 'int'>
class solidfire.models.GetVolumeStatsResult(volume_stats)[source]

Bases: solidfire.common.model.DataObject

Parameters:volume_stats (VolumeStats) – [required] Volume activity information.
volume_stats = <class 'solidfire.models.VolumeStats'>
class solidfire.models.GroupCloneVolumeMember(volume_id, src_volume_id)[source]

Bases: solidfire.common.model.DataObject

Represents the relationship between the source Volume and cloned Volume IDs.

Parameters:
  • volume_id (int) – [required] The VolumeID of the cloned volume.
  • src_volume_id (int) – [required] The VolumeID of the source volume.
src_volume_id = <type 'int'>
volume_id = <type 'int'>
class solidfire.models.GroupSnapshot(group_snapshot_id, group_snapshot_uuid, members, name, create_time, status, enable_remote_replication, attributes, remote_statuses=None)[source]

Bases: solidfire.common.model.DataObject

Group Snapshot object represents a point-in-time copy of a group of volumes.

Parameters:
  • group_snapshot_id (int) – [required] Unique ID of the new group snapshot.
  • group_snapshot_uuid (UUID) – [required] UUID of the group snapshot.
  • members (Snapshot) – [required] List of snapshots that are members of the group.
  • name (str) – [required] Name of the group snapshot, or, if none was given, the UTC formatted day and time on which the snapshot was created.
  • create_time (str) – [required] The UTC formatted day and time on which the snapshot was created.
  • status (str) – [required] Status of the snapshot. Possible values: Preparing: A snapshot that is being prepared for use and is not yet writable. Done: A snapshot that has finished being prepared and is now usable
  • enable_remote_replication (bool) – [required] Identifies if group snapshot is enabled for remote replication.
  • remote_statuses (GroupSnapshotRemoteStatus) – Replication status of the group snapshot as seen on the source cluster. Shows if the group snapshot replication is currently in progress, or has successfully completed.
  • attributes (dict) – [required] List of Name/Value pairs in JSON object format.
attributes = <type 'dict'>
create_time = <type 'str'>
enable_remote_replication = <type 'bool'>
group_snapshot_id = <type 'int'>
group_snapshot_uuid = <class 'uuid.UUID'>
members = <class 'solidfire.models.Snapshot[]'>
name = <type 'str'>
remote_statuses = <class 'solidfire.models.GroupSnapshotRemoteStatus[]'>
status = <type 'str'>
class solidfire.models.GroupSnapshotMembers(volume_id, snapshot_id, checksum)[source]

Bases: solidfire.common.model.DataObject

List of checksum, volumeIDs and snapshotIDs for each member of the group.

Parameters:
  • volume_id (int) – [required] The source volume ID for the snapshot.
  • snapshot_id (int) – [required] Unique ID of a snapshot from which the new snapshot is made. The snapshotID passed must be a snapshot on the given volume.
  • checksum (str) – [required] A string that represents the correct digits in the stored snapshot. This checksum can be used later to compare other snapshots to detect errors in the data.
checksum = <type 'str'>
snapshot_id = <type 'int'>
volume_id = <type 'int'>
class solidfire.models.GroupSnapshotRemoteStatus(remote_status)[source]

Bases: solidfire.common.model.DataObject

Parameters:remote_status (RemoteClusterSnapshotStatus) – [required] Current status of the remote group snapshot on the target cluster as seen on the source cluster
remote_status = <class 'solidfire.models.RemoteClusterSnapshotStatus'>
class solidfire.models.ISCSISession(account_id, account_name, drive_id, initiator_ip, initiator_port_name, target_port_name, initiator_name, node_id, service_id, session_id, target_name, target_ip, virtual_network_id, volume_id, create_time, volume_instance, initiator_session_id, drive_ids=None, initiator=None, ms_since_last_scsi_command=None, ms_since_last_iscsi_pdu=None)[source]

Bases: solidfire.common.model.DataObject

Parameters:
  • drive_ids (int) –
  • account_id (int) – [required]
  • initiator (Initiator) –
  • account_name (str) – [required]
  • drive_id (int) – [required]
  • initiator_ip (str) – [required]
  • initiator_port_name (str) – [required]
  • target_port_name (str) – [required]
  • initiator_name (str) – [required]
  • node_id (int) – [required]
  • service_id (int) – [required]
  • session_id (int) – [required]
  • target_name (str) – [required]
  • target_ip (str) – [required]
  • virtual_network_id (int) – [required]
  • volume_id (int) – [required]
  • create_time (str) – [required]
  • volume_instance (int) – [required]
  • initiator_session_id (int) – [required]
  • ms_since_last_scsi_command (int) –
  • ms_since_last_iscsi_pdu (int) –
account_id = <type 'int'>
account_name = <type 'str'>
create_time = <type 'str'>
drive_id = <type 'int'>
drive_ids = <type 'int[]'>
initiator = <class 'solidfire.models.Initiator'>
initiator_ip = <type 'str'>
initiator_name = <type 'str'>
initiator_port_name = <type 'str'>
initiator_session_id = <type 'int'>
ms_since_last_iscsi_pdu = <type 'int'>
ms_since_last_scsi_command = <type 'int'>
node_id = <type 'int'>
service_id = <type 'int'>
session_id = <type 'int'>
target_ip = <type 'str'>
target_name = <type 'str'>
target_port_name = <type 'str'>
virtual_network_id = <type 'int'>
volume_id = <type 'int'>
volume_instance = <type 'int'>
class solidfire.models.IdpConfigInfo(idp_configuration_id, idp_name, idp_metadata, sp_metadata_url, service_provider_certificate, enabled)[source]

Bases: solidfire.common.model.DataObject

Configuration and integration details regarding a third party Identity Provider (IdP).

Parameters:
  • idp_configuration_id (UUID) – [required] UUID for the third party Identity Provider (IdP) Configuration.
  • idp_name (str) – [required] Name for retrieving IdP provider for SAML 2.0 single sign-on.
  • idp_metadata (str) – [required] Metadata for configuration and integration details for SAML 2.0 single sign-on.
  • sp_metadata_url (str) – [required] URL for retrieving Service Provider (SP) Metadata from the Cluster to provide to the IdP for establish a trust relationship.
  • service_provider_certificate (str) – [required] A PEM format Base64 encoded PKCS#10 X.509 certificate to be used for communication with this IDP.
  • enabled (bool) – [required] Whether this third party Identity Provider configuration is enabled.
enabled = <type 'bool'>
idp_configuration_id = <class 'uuid.UUID'>
idp_metadata = <type 'str'>
idp_name = <type 'str'>
service_provider_certificate = <type 'str'>
sp_metadata_url = <type 'str'>
class solidfire.models.InitializeSnapMirrorRelationshipRequest(snap_mirror_endpoint_id, destination_volume, max_transfer_rate=None)[source]

Bases: solidfire.common.model.DataObject

The SolidFire Element OS web UI uses the InitializeSnapMirrorRelationship method to initialize the destination volume in a SnapMirror relationship by performing an initial baseline transfer between clusters.

Parameters:
  • snap_mirror_endpoint_id (int) – [required] The ID of the remote ONTAP system.
  • destination_volume (SnapMirrorVolumeInfo) – [required] The destination volume’s name in the SnapMirror relationship.
  • max_transfer_rate (int) – Specifies the maximum data transfer rate between the volumes in kilobytes per second. The default value, 0, is unlimited and permits the SnapMirror relationship to fully utilize the available network bandwidth.
destination_volume = <class 'solidfire.models.SnapMirrorVolumeInfo'>
max_transfer_rate = <type 'int'>
snap_mirror_endpoint_id = <type 'int'>
class solidfire.models.InitializeSnapMirrorRelationshipResult(snap_mirror_relationship)[source]

Bases: solidfire.common.model.DataObject

Parameters:snap_mirror_relationship (SnapMirrorRelationship) – [required] Information about the initialized SnapMirror relationship.
snap_mirror_relationship = <class 'solidfire.models.SnapMirrorRelationship'>
class solidfire.models.Initiator(alias, initiator_id, initiator_name, volume_access_groups, attributes, require_chap, virtual_network_ids, chap_username=None, initiator_secret=None, target_secret=None)[source]

Bases: solidfire.common.model.DataObject

Object containing characteristics of each initiator

Parameters:
  • alias (str) – [required] The friendly name assigned to this initiator.
  • initiator_id (int) – [required] The numeric ID of the initiator that has been created.
  • initiator_name (str) – [required] The name of the initiator that has been created.
  • volume_access_groups (int) – [required] A list of volumeAccessGroupIDs to which this initiator belongs.
  • attributes (dict) – [required] A set of JSON attributes assigned to this initiator.
  • require_chap (bool) – [required] True if CHAP is required for this Initiator.
  • chap_username (str) – The unique CHAP username for this initiator.
  • initiator_secret (CHAPSecret) – The CHAP secret used to authenticate the initiator.
  • target_secret (CHAPSecret) – The CHAP secret used to authenticate the target (mutual CHAP authentication).
  • virtual_network_ids (int) – [required] The list of virtual network identifiers associated with this initiator. If one or more are defined, this initiator will only be able to login to the specified virtual networks. If no virtual networks are defined this initiator can login to all networks.
alias = <type 'str'>
attributes = <type 'dict'>
chap_username = <type 'str'>
initiator_id = <type 'int'>
initiator_name = <type 'str'>
initiator_secret = <class 'solidfire.models.CHAPSecret'>
require_chap = <type 'bool'>
target_secret = <class 'solidfire.models.CHAPSecret'>
virtual_network_ids = <type 'int[]'>
volume_access_groups = <type 'int[]'>
class solidfire.models.InvokeSFApiRequest(method, parameters=None)[source]

Bases: solidfire.common.model.DataObject

This will invoke any API method supported by the SolidFire API for the version and port the connection is using. Returns a nested hashtable of key/value pairs that contain the result of the invoked method.

Parameters:
  • method (str) – [required] The name of the method to invoke. This is case sensitive.
  • parameters (str) – An object, normally a dictionary or hashtable of the key/value pairs, to be passed as the params for the method being invoked.
method = <type 'str'>
parameters = <type 'str'>
class solidfire.models.IpmiInfo(sensors)[source]

Bases: solidfire.common.model.DataObject

Parameters:sensors (dict) – [required]
sensors = <type 'dict[]'>
class solidfire.models.KeyProviderKmip(key_provider_name, key_provider_id, key_provider_is_active, key_server_ids, kmip_capabilities)[source]

Bases: solidfire.common.model.DataObject

A Key Provider describes both a mechanism and a location for retrieving authentication keys for use with cluster features such as Encryption At Rest. Some Key Providers may imply that there can only be one Key Provider of that type, while others may allow multiple Key Providers of the same type but retrieving authentication keys from different locations for different purposes. A KMIP (Key Management Interoperability Protocol) Key Provider can represent a single KMIP server, a logical cluster of KMIP servers which should be kept in sync, or an actual cluster which we treat as a single server. There can be multiple KMIP Key Providers but they must contain mutually-exclusive sets of servers. Key UUID’s will only be considered as unique within a Key Provider so there could be collisions (and resulting errors) otherwise.

Parameters:
  • key_provider_name (str) – [required] The name of the KMIP Key Provider.
  • key_provider_id (int) – [required] The ID of the KMIP Key Provider. This is a unique value assigned by the cluster during CreateKeyProviderKmip which cannot be changed.
  • key_provider_is_active (bool) – [required] True if the KMIP Key Provider is active. A provider is considered active if are still outstanding keys which were created but not yet deleted and therefore assumed to still be in use.
  • key_server_ids (int) – [required] A list of keyServerIDs which are grouped together within this provider. At least one server must be added via AddKeyServerToProviderKmip before this provider can become active. The last server cannot be removed via RemoveKeyServerFromProviderKmip or DeleteKeyServerKmip while this provider is active.
  • kmip_capabilities (str) – [required] The capabilities of this KMIP Key Provider including details about the underlying library, FIPS compliance, SSL provider, etc.
key_provider_id = <type 'int'>
key_provider_is_active = <type 'bool'>
key_provider_name = <type 'str'>
key_server_ids = <type 'int[]'>
kmip_capabilities = <type 'str'>
class solidfire.models.KeyServerKmip(kmip_ca_certificate, kmip_client_certificate, kmip_key_server_hostnames, key_server_id, kmip_key_server_name, kmip_key_server_port, key_provider_id=None, kmip_assigned_provider_is_active=None)[source]

Bases: solidfire.common.model.DataObject

A KMIP (Key Management Interoperability Protocol) Key Server describes a location for retrieving authentication keys for use with cluster features such as Encryption At Rest.

Parameters:
  • key_provider_id (int) – If this KMIP Key Server is assigned to a provider, this field will contain the ID of the KMIP Key Provider it’s assigned to. Otherwise it will be null.
  • kmip_assigned_provider_is_active (bool) – If this KMIP Key Server is assigned to a provider (keyProviderID is not null), this field will indicate whether that provider is active (providing keys which are currently in use). Otherwise it will be null.
  • kmip_ca_certificate (str) – [required] The public key certificate of the external key server’s root CA. This will be used to verify the certificate presented by external key server in the TLS communication. For key server clusters where individual servers use different CAs, provide a concatenated string containing the root certificates of all the CAs.
  • kmip_client_certificate (str) – [required] A PEM format Base64 encoded PKCS#10 X.509 certificate used by the Solidfire KMIP client.
  • kmip_key_server_hostnames (str) – [required] The hostnames or IP addresses associated with this KMIP Key Server.
  • key_server_id (int) – [required] The ID of the KMIP Key Server. This is a unique value assigned by the cluster during CreateKeyServer which cannot be changedKmip.
  • kmip_key_server_name (str) – [required] The name of the KMIP Key Server. This name is only used for display purposes and does not need to be unique.
  • kmip_key_server_port (int) – [required] The port number associated with this KMIP Key Server (typically 5696).
key_provider_id = <type 'int'>
key_server_id = <type 'int'>
kmip_assigned_provider_is_active = <type 'bool'>
kmip_ca_certificate = <type 'str'>
kmip_client_certificate = <type 'str'>
kmip_key_server_hostnames = <type 'str[]'>
kmip_key_server_name = <type 'str'>
kmip_key_server_port = <type 'int'>
class solidfire.models.LdapConfiguration(auth_type, enabled, group_search_base_dn, group_search_custom_filter, group_search_type, search_bind_dn, server_uris, user_dntemplate, user_search_base_dn, user_search_filter)[source]

Bases: solidfire.common.model.DataObject

LDAP Configuration object returns information about the LDAP configuration on SolidFire storage. LDAP information is returned with the API method GetLdapConfiguration.

Parameters:
  • auth_type (str) – [required] Identifies which user authentcation method will be used. Valid values: DirectBind SearchAndBind
  • enabled (bool) – [required] Identifies whether or not the system is enabled for LDAP. Valid values: true false
  • group_search_base_dn (str) – [required] The base DN of the tree to start the group search (will do a subtree search from here).
  • group_search_custom_filter (str) – [required] The custom search filter used.
  • group_search_type (str) – [required] Controls the default group search filter used, can be one of the following: NoGroups: No group support. ActiveDirectory: Nested membership of all of a user’s AD groups. MemberDN: MemberDN style groups (single-level).
  • search_bind_dn (str) – [required] A fully qualified DN to log in with to perform an LDAP search for the user (needs read access to the LDAP directory).
  • server_uris (str) – [required] A comma-separated list of LDAP server URIs (examples: “ldap://1.2.3.4” and ldaps://1.2.3.4:123”)
  • user_dntemplate (str) – [required] A string that is used to form a fully qualified user DN.
  • user_search_base_dn (str) – [required] The base DN of the tree used to start the search (will do a subtree search from here).
  • user_search_filter (str) – [required] The LDAP filter used.
auth_type = <type 'str'>
enabled = <type 'bool'>
group_search_base_dn = <type 'str'>
group_search_custom_filter = <type 'str'>
group_search_type = <type 'str'>
search_bind_dn = <type 'str'>
server_uris = <type 'str[]'>
user_dntemplate = <type 'str'>
user_search_base_dn = <type 'str'>
user_search_filter = <type 'str'>
class solidfire.models.ListAccountsRequest(start_account_id=None, limit=None, include_storage_containers=None)[source]

Bases: solidfire.common.model.DataObject

ListAccounts returns the entire list of accounts, with optional paging support.

Parameters:
  • start_account_id (int) – Starting AccountID to return. If no account exists with this AccountID, the next account by AccountID order is used as the start of the list. To page through the list, pass the AccountID of the last account in the previous response + 1.
  • limit (int) – Maximum number of AccountInfo objects to return.
  • include_storage_containers (bool) – Includes storage containers in the response by default. To exclude storage containers, set to false.
include_storage_containers = <type 'bool'>
limit = <type 'int'>
start_account_id = <type 'int'>
class solidfire.models.ListAccountsResult(accounts)[source]

Bases: solidfire.common.model.DataObject

Parameters:accounts (Account) – [required] List of accounts.
accounts = <class 'solidfire.models.Account[]'>
class solidfire.models.ListActiveNodesResult(nodes)[source]

Bases: solidfire.common.model.DataObject

Parameters:nodes (Node) – [required]
nodes = <class 'solidfire.models.Node[]'>
class solidfire.models.ListActivePairedVolumesRequest(start_volume_id=None, limit=None)[source]

Bases: solidfire.common.model.DataObject

ListActivePairedVolumes enables you to list all the active volumes paired with a volume. This method returns information about volumes with active and pending pairings.

Parameters:
  • start_volume_id (int) – The beginning of the range of active paired volumes to return.
  • limit (int) – Maximum number of active paired volumes to return.
limit = <type 'int'>
start_volume_id = <type 'int'>
class solidfire.models.ListActivePairedVolumesResult(volumes)[source]

Bases: solidfire.common.model.DataObject

Parameters:volumes (Volume) – [required] Volume information for the paired volumes.
volumes = <class 'solidfire.models.Volume[]'>
class solidfire.models.ListActiveVolumesRequest(start_volume_id=None, limit=None, include_virtual_volumes=None)[source]

Bases: solidfire.common.model.DataObject

ListActiveVolumes enables you to return the list of active volumes currently in the system. The list of volumes is returned sorted in VolumeID order and can be returned in multiple parts (pages).

Parameters:
  • start_volume_id (int) – Starting VolumeID to return. If no volume exists with this VolumeID, the next volume by VolumeID order is used as the start of the list. To page through the list, pass the VolumeID of the last volume in the previous response + 1.
  • limit (int) – Maximum number of Volume Info objects to return. A value of 0 (zero) returns all volumes (unlimited).
  • include_virtual_volumes (bool) – Specifies that virtual volumes are included in the response by default. To exclude virtual volumes, set to false.
include_virtual_volumes = <type 'bool'>
limit = <type 'int'>
start_volume_id = <type 'int'>
class solidfire.models.ListActiveVolumesResult(volumes)[source]

Bases: solidfire.common.model.DataObject

Parameters:volumes (Volume) – [required] List of active volumes.
volumes = <class 'solidfire.models.Volume[]'>
class solidfire.models.ListAllNodesResult(nodes, pending_nodes, pending_active_nodes=None)[source]

Bases: solidfire.common.model.DataObject

Parameters:
  • nodes (Node) – [required]
  • pending_nodes (PendingNode) – [required]
  • pending_active_nodes (PendingActiveNode) – List of objects detailing information about all PendingActive nodes in the system.
nodes = <class 'solidfire.models.Node[]'>
pending_active_nodes = <class 'solidfire.models.PendingActiveNode[]'>
pending_nodes = <class 'solidfire.models.PendingNode[]'>
class solidfire.models.ListAsyncResultsRequest(async_result_types=None)[source]

Bases: solidfire.common.model.DataObject

You can use ListAsyncResults to list the results of all currently running and completed asynchronous methods on the system. Querying asynchronous results with ListAsyncResults does not cause completed asyncHandles to expire; you can use GetAsyncResult to query any of the asyncHandles returned by ListAsyncResults.

Parameters:async_result_types (str) – An optional list of types of results. You can use this list to restrict the results to only these types of operations. Possible values are: BulkVolume: Copy operations between volumes, such as backups or restores. Clone: Volume cloning operations. DriveRemoval: Operations involving the system copying data from a drive in preparation to remove it from the cluster. RtfiPendingNode: Operations involving the system installing compatible software on a node before adding it to the cluster
async_result_types = <type 'str[]'>
class solidfire.models.ListAsyncResultsResult(async_handles)[source]

Bases: solidfire.common.model.DataObject

Parameters:async_handles (AsyncHandle) – [required] An array of serialized asynchronous method results.
async_handles = <class 'solidfire.models.AsyncHandle[]'>
class solidfire.models.ListAuthSessionsByClusterAdminRequest(cluster_admin_id)[source]

Bases: solidfire.common.model.DataObject

List all auth sessions associated with the specified ClusterAdminID. If the specified ClusterAdminID maps to a group of users, all auth sessions for all members of that group will be listed.

Parameters:cluster_admin_id (int) – [required] ID that identifies a clusterAdmin.
cluster_admin_id = <type 'int'>
class solidfire.models.ListAuthSessionsByUsernameRequest(username=None, auth_method=None)[source]

Bases: solidfire.common.model.DataObject

Lists all auth sessions for the given user. A caller not in AccessGroup ClusterAdmins / Administrator privileges may only list their own sessions. A caller with ClusterAdmins / Administrator privileges may list sessions belonging to any user.

Parameters:
  • username (str) – Name that uniquely identifies the user. When authMethod is Cluster, this specifies the ClusterAdmin username. When authMethod is Ldap, this specifies the user’s LDAP DN. When authMethod is Idp, this may specify the user’s IdP uid or NameID. If the IdP is not configured to return either, this specifies a random UUID issued when the session was created. Only a caller in the ClusterAdmins / Administrator AccessGroup can provide this parameter.
  • auth_method (AuthMethod) – Authentication method of the user sessions to be listed. Only a caller in the ClusterAdmins / Administrator AccessGroup can provide this parameter.
auth_method = <class 'solidfire.models.AuthMethod'>
username = <type 'str'>
class solidfire.models.ListAuthSessionsResult(sessions)[source]

Bases: solidfire.common.model.DataObject

Returns a list of AuthSessionInfos.

Parameters:sessions (AuthSessionInfo) – [required] List of AuthSessionInfos.
sessions = <class 'solidfire.models.AuthSessionInfo[]'>
class solidfire.models.ListBackupTargetsResult(backup_targets)[source]

Bases: solidfire.common.model.DataObject

Parameters:backup_targets (BackupTarget) – [required] Objects returned for each backup target.
backup_targets = <class 'solidfire.models.BackupTarget[]'>
class solidfire.models.ListBulkVolumeJobsResult(bulk_volume_jobs)[source]

Bases: solidfire.common.model.DataObject

Parameters:bulk_volume_jobs (BulkVolumeJob) – [required] An array of information for each bulk volume job.
bulk_volume_jobs = <class 'solidfire.models.BulkVolumeJob[]'>
class solidfire.models.ListClusterAdminsResult(cluster_admins)[source]

Bases: solidfire.common.model.DataObject

Parameters:cluster_admins (ClusterAdmin) – [required] Information about the cluster admin.
cluster_admins = <class 'solidfire.models.ClusterAdmin[]'>
class solidfire.models.ListClusterFaultsRequest(best_practices=None, fault_types=None)[source]

Bases: solidfire.common.model.DataObject

ListClusterFaults enables you to retrieve information about any faults detected on the cluster. With this method, you can retrieve both current faults as well as faults that have been resolved. The system caches faults every 30 seconds.

Parameters:
  • best_practices (bool) – Specifies whether to include faults triggered by suboptimal system configuration. Possible values are: true false
  • fault_types (str) – Determines the types of faults returned. Possible values are: current: List active, unresolved faults. resolved: List faults that were previously detected and resolved. all: (Default) List both current and resolved faults. You can see the fault status in the resolved field of the Cluster Fault object.
best_practices = <type 'bool'>
fault_types = <type 'str'>
class solidfire.models.ListClusterFaultsResult(faults)[source]

Bases: solidfire.common.model.DataObject

Parameters:faults (ClusterFaultInfo) – [required] The list of Cluster Fault objects.
faults = <class 'solidfire.models.ClusterFaultInfo[]'>
class solidfire.models.ListClusterInterfacePreferencesResult(preferences)[source]

Bases: solidfire.common.model.DataObject

Parameters:preferences (ClusterInterfacePreference) – [required] The cluster interface preferences.
preferences = <class 'solidfire.models.ClusterInterfacePreference[]'>
class solidfire.models.ListClusterPairsResult(cluster_pairs)[source]

Bases: solidfire.common.model.DataObject

Parameters:cluster_pairs (PairedCluster) – [required] Information about each paired cluster.
cluster_pairs = <class 'solidfire.models.PairedCluster[]'>
class solidfire.models.ListDeletedVolumesRequest(include_virtual_volumes=None)[source]

Bases: solidfire.common.model.DataObject

ListDeletedVolumes enables you to retrieve the list of volumes that have been marked for deletion and purged from the system.

Parameters:include_virtual_volumes (bool) – Specifies that virtual volumes are included in the response by default. To exclude virtual volumes, set to false.
include_virtual_volumes = <type 'bool'>
class solidfire.models.ListDeletedVolumesResult(volumes)[source]

Bases: solidfire.common.model.DataObject

Parameters:volumes (Volume) – [required] List of deleted volumes.
volumes = <class 'solidfire.models.Volume[]'>
class solidfire.models.ListDriveHardwareRequest(force)[source]

Bases: solidfire.common.model.DataObject

ListDriveHardware returns all the drives connected to a node. Use this method on individual nodes to return drive hardware information or use this method on the cluster master node MVIP to see information for all the drives on all nodes. Note: The “securitySupported”: true line of the method response does not imply that the drives are capable of encryption; only that the security status can be queried. If you have a node type with a model number ending in “-NE”, commands to enable security features on these drives will fail. See the EnableEncryptionAtRest method for more information.

Parameters:force (bool) – [required] To run this command, the force parameter must be set to true.
force = <type 'bool'>
class solidfire.models.ListDriveHardwareResult(nodes)[source]

Bases: solidfire.common.model.DataObject

Parameters:nodes (NodeDriveHardware) – [required]
nodes = <class 'solidfire.models.NodeDriveHardware[]'>
class solidfire.models.ListDriveStatsRequest(drives=None)[source]

Bases: solidfire.common.model.DataObject

ListDriveStats enables you to retrieve high-level activity measurements for multiple drives in the cluster. By default, this method returns statistics for all drives in the cluster, and these measurements are cumulative from the addition of the drive to the cluster. Some values this method returns are specific to block drives, and some are specific to metadata drives.

Parameters:drives (int) – Optional list of DriveIDs for which to return drive statistics. If you omit this parameter, measurements for all drives are returned.
drives = <type 'int[]'>
class solidfire.models.ListDriveStatsResult(drive_stats, errors)[source]

Bases: solidfire.common.model.DataObject

Parameters:
  • drive_stats (DriveStats) – [required] List of drive activity information for each drive.
  • errors (dict) – [required] If there are errors retrieving information about a drive, this list contains the driveID and associated error message. Always present, and empty if there are no errors.
drive_stats = <class 'solidfire.models.DriveStats[]'>
errors = <type 'dict[]'>
class solidfire.models.ListDrivesResult(drives)[source]

Bases: solidfire.common.model.DataObject

Parameters:drives (DriveInfo) – [required] Information for the drives that are connected to the cluster.
drives = <class 'solidfire.models.DriveInfo[]'>
class solidfire.models.ListEventsRequest(max_events=None, start_event_id=None, end_event_id=None, event_type=None, service_id=None, node_id=None, drive_id=None, start_report_time=None, end_report_time=None, start_publish_time=None, end_publish_time=None)[source]

Bases: solidfire.common.model.DataObject

ListEvents returns events detected on the cluster, sorted from oldest to newest.

Parameters:
  • max_events (int) – Specifies the maximum number of events to return.
  • start_event_id (int) – Specifies the beginning of a range of events to return.
  • end_event_id (int) – Specifies the end of a range of events to return.
  • event_type (str) – Specifies the type of events to return.
  • service_id (int) – Specifies that only events with this ServiceID will be returned.
  • node_id (int) – Specifies that only events with this NodeID will be returned.
  • drive_id (int) – Specifies that only events with this DriveID will be returned.
  • start_report_time (str) – Specifies that only events reported after this time will be returned.
  • end_report_time (str) – Specifies that only events reported earlier than this time will be returned.
  • start_publish_time (str) – Specifies that only events published after this time will be returned.
  • end_publish_time (str) – Specifies that only events published earlier than this time will be returned.
drive_id = <type 'int'>
end_event_id = <type 'int'>
end_publish_time = <type 'str'>
end_report_time = <type 'str'>
event_type = <type 'str'>
max_events = <type 'int'>
node_id = <type 'int'>
service_id = <type 'int'>
start_event_id = <type 'int'>
start_publish_time = <type 'str'>
start_report_time = <type 'str'>
class solidfire.models.ListEventsResult(event_queue_type, events)[source]

Bases: solidfire.common.model.DataObject

Parameters:
  • event_queue_type (str) – [required] event queue type
  • events (EventInfo) – [required] list of events
event_queue_type = <type 'str'>
events = <class 'solidfire.models.EventInfo[]'>
class solidfire.models.ListFibreChannelPortInfoResult(fibre_channel_port_info)[source]

Bases: solidfire.common.model.DataObject

ListFibreChannelPortInfoResult is used to return information about the Fibre Channel ports.

Parameters:fibre_channel_port_info (dict) – [required] Used to return information about the Fibre Channel ports.
fibre_channel_port_info = <type 'dict'>
class solidfire.models.ListFibreChannelSessionsResult(sessions)[source]

Bases: solidfire.common.model.DataObject

Used to return information about the Fibre Channel sessions.

Parameters:sessions (FibreChannelSession) – [required] A list of FibreChannelSession objects with information about the Fibre Channel session.
sessions = <class 'solidfire.models.FibreChannelSession[]'>
class solidfire.models.ListGroupSnapshotsRequest(volumes=None, group_snapshot_id=None)[source]

Bases: solidfire.common.model.DataObject

ListGroupSnapshots enables you to get information about all group snapshots that have been created.

Parameters:
  • volumes (int) – An array of unique volume IDs to query. If you do not specify this parameter, all group snapshots on the cluster are included.
  • group_snapshot_id (int) – Retrieves information for a specific group snapshot ID.
group_snapshot_id = <type 'int'>
volumes = <type 'int[]'>
class solidfire.models.ListGroupSnapshotsResult(group_snapshots)[source]

Bases: solidfire.common.model.DataObject

Parameters:group_snapshots (GroupSnapshot) – [required] List of Group Snapshots.
group_snapshots = <class 'solidfire.models.GroupSnapshot[]'>
class solidfire.models.ListISCSISessionsResult(sessions)[source]

Bases: solidfire.common.model.DataObject

Parameters:sessions (ISCSISession) – [required]
sessions = <class 'solidfire.models.ISCSISession[]'>
class solidfire.models.ListIdpConfigurationsRequest(idp_configuration_id=None, idp_name=None, enabled_only=None)[source]

Bases: solidfire.common.model.DataObject

List configurations for third party Identity Provider(s) (IdP), optionally providing either enabledOnly flag to retrieve the currently enabled IdP configuration, or an IdP metadata UUID or IdP name to query a specific IdP configuration information.

Parameters:
  • idp_configuration_id (UUID) – UUID for the third party Identity Provider (IdP) Configuration.
  • idp_name (str) – Filters the result to an IdP configuration information for a specific IdP name.
  • enabled_only (bool) – Filters the result to return the currently enabled Idp configuration.
enabled_only = <type 'bool'>
idp_configuration_id = <class 'uuid.UUID'>
idp_name = <type 'str'>
class solidfire.models.ListIdpConfigurationsResult(idp_config_infos)[source]

Bases: solidfire.common.model.DataObject

Parameters:idp_config_infos (IdpConfigInfo) – [required] Information around the third party Identity Provider (IdP) configuration(s).
idp_config_infos = <class 'solidfire.models.IdpConfigInfo[]'>
class solidfire.models.ListInitiatorsRequest(start_initiator_id=None, limit=None, initiators=None)[source]

Bases: solidfire.common.model.DataObject

ListInitiators enables you to list initiator IQNs or World Wide Port Names (WWPNs).

Parameters:
  • start_initiator_id (int) – The initiator ID at which to begin the listing. You can supply this parameter or the “initiators” parameter, but not both.
  • limit (int) – The maximum number of initiator objects to return.
  • initiators (int) – A list of initiator IDs to retrieve. You can provide a value for this parameter or the “startInitiatorID” parameter, but not both.
initiators = <type 'int[]'>
limit = <type 'int'>
start_initiator_id = <type 'int'>
class solidfire.models.ListInitiatorsResult(initiators)[source]

Bases: solidfire.common.model.DataObject

Parameters:initiators (Initiator) – [required] List of the initiator information.
initiators = <class 'solidfire.models.Initiator[]'>
class solidfire.models.ListKeyProvidersKmipRequest(key_provider_is_active=None, kmip_key_provider_has_server_assigned=None)[source]

Bases: solidfire.common.model.DataObject

Returns the list of KMIP (Key Management Interoperability Protocol) Key Providers which have been created via CreateKeyProviderKmip. The list can optionally be filtered by specifying additional parameters.

Parameters:
  • key_provider_is_active (bool) – If omitted, returned KMIP Key Provider objects will not be filtered based on whether they’re active. If true, returns only KMIP Key Provider objects which are active (providing keys which are currently in use). If false, returns only KMIP Key Provider objects which are inactive (not providing any keys and able to be deleted).
  • kmip_key_provider_has_server_assigned (bool) – If omitted, returned KMIP Key Provider objects will not be filtered based on whether they have a KMIP Key Server assigned. If true, returns only KMIP Key Provider objects which have a KMIP Key Server assigned. If false, returns only KMIP Key Provider objects which do not have a KMIP Key Server assigned.
key_provider_is_active = <type 'bool'>
kmip_key_provider_has_server_assigned = <type 'bool'>
class solidfire.models.ListKeyProvidersKmipResult(kmip_key_providers)[source]

Bases: solidfire.common.model.DataObject

Parameters:kmip_key_providers (KeyProviderKmip) – [required] A list of KMIP (Key Management Interoperability Protocol) Key Providers which have been created via CreateKeyProviderKmip.
kmip_key_providers = <class 'solidfire.models.KeyProviderKmip[]'>
class solidfire.models.ListKeyServersKmipRequest(key_provider_id=None, kmip_assigned_provider_is_active=None, kmip_has_provider_assigned=None)[source]

Bases: solidfire.common.model.DataObject

Returns the list of KMIP (Key Management Interoperability Protocol) Key Servers which have been created via CreateKeyServerKmip. The list can optionally be filtered by specifying additional parameters.

Parameters:
  • key_provider_id (int) – If omitted, returned KMIP Key Server objects will not be filtered based on whether they’re assigned to the specified KMIP Key Provider. If specified, returned KMIP Key Server objects will be filtered to those assigned to the specified KMIP Key Provider.
  • kmip_assigned_provider_is_active (bool) – If omitted, returned KMIP Key Server objects will not be filtered based on whether they’re active. If true, returns only KMIP Key Server objects which are active (providing keys which are currently in use). If false, returns only KMIP Key Server objects which are inactive (not providing any keys and able to be deleted).
  • kmip_has_provider_assigned (bool) – If omitted, returned KMIP Key Server objects will not be filtered based on whether they have a KMIP Key Provider assigned. If true, returns only KMIP Key Server objects which have a KMIP Key Provider assigned. If false, returns only KMIP Key Server objects which do not have a KMIP Key Provider assigned.
key_provider_id = <type 'int'>
kmip_assigned_provider_is_active = <type 'bool'>
kmip_has_provider_assigned = <type 'bool'>
class solidfire.models.ListKeyServersKmipResult(kmip_key_servers)[source]

Bases: solidfire.common.model.DataObject

Parameters:kmip_key_servers (KeyServerKmip) – [required] The complete list of KMIP (Key Management Interoperability Protocol) Key Servers which have been created via CreateKeyServerKmip.
kmip_key_servers = <class 'solidfire.models.KeyServerKmip[]'>
class solidfire.models.ListNetworkInterfacesResult(interfaces)[source]

Bases: solidfire.common.model.DataObject

Parameters:interfaces (NetworkInterface) – [required]
interfaces = <class 'solidfire.models.NetworkInterface[]'>
class solidfire.models.ListNodeFibreChannelPortInfoResult(fibre_channel_ports)[source]

Bases: solidfire.common.model.DataObject

List of fibre channel port info results grouped by node.

Parameters:fibre_channel_ports (FibreChannelPortInfo) – [required] List of all physical Fibre Channel ports.
fibre_channel_ports = <class 'solidfire.models.FibreChannelPortInfo[]'>
class solidfire.models.ListNodeStatsResult(node_stats)[source]

Bases: solidfire.common.model.DataObject

Parameters:node_stats (NodeStatsNodes) – [required] Node activity information for all nodes.
node_stats = <class 'solidfire.models.NodeStatsNodes'>
class solidfire.models.ListPendingActiveNodesResult(pending_active_nodes)[source]

Bases: solidfire.common.model.DataObject

Parameters:pending_active_nodes (PendingActiveNode) – [required] List of objects detailing information about all PendingActive nodes in the system.
pending_active_nodes = <class 'solidfire.models.PendingActiveNode[]'>
class solidfire.models.ListPendingNodesResult(pending_nodes)[source]

Bases: solidfire.common.model.DataObject

Parameters:pending_nodes (PendingNode) – [required]
pending_nodes = <class 'solidfire.models.PendingNode[]'>
class solidfire.models.ListProtectionDomainLevelsResult(protection_domain_levels)[source]

Bases: solidfire.common.model.DataObject

Parameters:protection_domain_levels (ProtectionDomainLevel) – [required] A list of the different Protection Domain Levels, where each supplies the cluster’s Tolerance and Resiliency information from its own perspective. This will include an element for each of the defined Protection Domain Types.
protection_domain_levels = <class 'solidfire.models.ProtectionDomainLevel[]'>
class solidfire.models.ListProtocolEndpointsRequest(protocol_endpoint_ids=None)[source]

Bases: solidfire.common.model.DataObject

ListProtocolEndpoints enables you to retrieve information about all protocol endpoints in the cluster. Protocol endpoints govern access to their associated virtual volume storage containers.

Parameters:protocol_endpoint_ids (UUID) – A list of protocol endpoint IDs for which to retrieve information. If you omit this parameter, the method returns information about all protocol endpoints.
protocol_endpoint_ids = <class 'uuid.UUID[]'>
class solidfire.models.ListProtocolEndpointsResult(protocol_endpoints)[source]

Bases: solidfire.common.model.DataObject

Parameters:protocol_endpoints (ProtocolEndpoint) – [required]
protocol_endpoints = <class 'solidfire.models.ProtocolEndpoint[]'>
class solidfire.models.ListQoSPoliciesResult(qos_policies)[source]

Bases: solidfire.common.model.DataObject

Parameters:qos_policies (QoSPolicy) – [required] A list of details about each QoS policy.
qos_policies = <class 'solidfire.models.QoSPolicy[]'>
class solidfire.models.ListSchedulesResult(schedules)[source]

Bases: solidfire.common.model.DataObject

Parameters:schedules (Schedule) – [required] The list of schedules currently on the cluster.
schedules = <class 'solidfire.models.Schedule[]'>
class solidfire.models.ListServicesResult(services)[source]

Bases: solidfire.common.model.DataObject

Parameters:services (DetailedService) – [required]
services = <class 'solidfire.models.DetailedService[]'>
class solidfire.models.ListSnapMirrorAggregatesRequest(snap_mirror_endpoint_id=None)[source]

Bases: solidfire.common.model.DataObject

The SolidFire Element OS web UI uses the ListSnapMirrorAggregates method to list all SnapMirror aggregates that are available on the remote ONTAP system. An aggregate describes a set of physical storage resources.

Parameters:snap_mirror_endpoint_id (int) – Return only the aggregates associated with the specified endpoint ID. If no endpoint ID is provided, the system lists aggregates from all known SnapMirror endpoints.
snap_mirror_endpoint_id = <type 'int'>
class solidfire.models.ListSnapMirrorAggregatesResult(snap_mirror_aggregates)[source]

Bases: solidfire.common.model.DataObject

Parameters:snap_mirror_aggregates (SnapMirrorAggregate) – [required] A list of the aggregates available on the ONTAP storage system.
snap_mirror_aggregates = <class 'solidfire.models.SnapMirrorAggregate[]'>
class solidfire.models.ListSnapMirrorEndpointsRequest(snap_mirror_endpoint_ids=None)[source]

Bases: solidfire.common.model.DataObject

The SolidFire Element OS web UI uses the ListSnapMirrorEndpoints method to list all SnapMirror endpoints that the SolidFire cluster is communicating with.

Parameters:snap_mirror_endpoint_ids (int) – Return only the objects associated with these IDs. If no IDs are provided or the array is empty, the method returns all SnapMirror endpoint IDs.
snap_mirror_endpoint_ids = <type 'int[]'>
class solidfire.models.ListSnapMirrorEndpointsResult(snap_mirror_endpoints)[source]

Bases: