netapp.santricity.api.symbol package¶

Submodules¶

netapp.santricity.api.symbol.a_api module¶

AApi.py

class netapp.santricity.api.symbol.a_api.AApi(api_client=None)[source]¶

Bases: object

symbol_activate_discrete_time_series(system_id, body, **kwargs)[source]¶

This procedure activates the collection of a set of statistics known as a “discrete time series” (discrete time) on each control of the array. A discrete time is a time-ordered sequence of observations of a single statistic, sampled at regular intervals. Documented return codes: ok, error, illegalParam, invalidRequest.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_activate_discrete_time_series(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (DiscreteTimeSeriesDescriptor) – A DiscreteTimeSeriesDescriptor structure containing the arguments for the procedure call. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	StatStreamIdReturned If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_activate_fibre_channel_check_point_based_async_mirroring(system_id, **kwargs)[source]¶

This procedure will enable mirroring over Fibre Channel (setup dedicated channel). Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_activate_fibre_channel_check_point_based_async_mirroring(system_id, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_activate_histogram(system_id, body, **kwargs)[source]¶

This procedure activates a type of statistics stream known as a histogram on each controller of the array. A histogram is a set of observations of a single statistic, organized into categories based on user criteria, with observation counts per category identified. Documented return codes: ok, error, illegalParam, invalidRequest.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_activate_histogram(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (HistogramDescriptor) – A HistogramDescriptor structure containing the arguments for the procedure call. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	StatStreamIdReturned If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_activate_host_port(system_id, body, **kwargs)[source]¶

Activates an inactive host port. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_activate_host_port(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_activate_initiator(system_id, body, **kwargs)[source]¶

Activates inactive iSCSI initiator. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_activate_initiator(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_activate_mirroring(system_id, **kwargs)[source]¶

Activate Remote Mirroring Documented return codes: ok, illegalParam, noHeap, internalError, iconFailure, metadataVolNonexistent, rvmFeatureDisabled, maxMirrorsExceeded, rvmFibreError.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_activate_mirroring(system_id, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_activate_staged_controller_firmware(system_id, **kwargs)[source]¶

Activate staged controller firmware Documented return codes: ok, error, busy, illegalParam, invalidRequest, voltransferError, downloadInProgress.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_activate_staged_controller_firmware(system_id, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_add_async_mirror_group_primary_member(system_id, body, **kwargs)[source]¶

This procedure will add a member to an Async Mirror Group on the primary array. This is step 1 of the add member process. Documented return codes: ok, invalidProtection, arvmGroupDoesNotExist, arvmGroupNotPrimary, arvmVolumeAlreadyInMirrorRelationship, arvmMemberLimitExceeded, incompatibleRepositorySecurity, arvmOrphanGroup, arvmRemoteMaxMirrorsPerArrayExceeded, remoteMaxTotalMirrorsPerArrayExceeded, remoteNoHeap, remoteInternalError, arvmRemoteGroupNotSecondary, arvmRemoteGroupDoesNotExist, remoteInvalidProtection, remoteDatabaseError, arvmRemoteThinNotSupported.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_add_async_mirror_group_primary_member(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (AsyncMirrorGroupAddPrimaryMemberDescriptor) – An object containing all of the attributes required to add a member to an Asynchronous Mirror Group on the primary array. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_add_async_mirror_group_secondary_member(system_id, body, **kwargs)[source]¶

This procedure will add a member to an Async Mirror Group on the secondary array. This is step 2 of the add member process. Documented return codes: ok, invalidProtection, invalidIncompleteMemberRef, arvmGroupNotSecondary, arvmInvalidMirrorState, arvmVolumeAlreadyInMirrorRelationship, incompatibleRepositorySecurity, incompatibleSecondarySecurity, arvmInvalidSecondaryCapacity, arvmOrphanGroup, remoteInternalError, remoteRvmSpmError, arvmRemoteMirrorMemberDoesNotExist, arvmRemoteGroupDoesNotExist, remoteDatabaseError, arvmIncorrectVolumeType, arvmThinVolInitError.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_add_async_mirror_group_secondary_member(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (AsyncMirrorGroupAddSecondaryMemberDescriptor) – An object containing all of the attributes required to add a member to an Asynchronous Mirror Group on the secondary array. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_add_drives_to_flash_cache(system_id, body, **kwargs)[source]¶

This procedure reconfigures the flash cache volume group to add additional drives. Documented return codes: ok, error, illegalParam, noHeap, driveNotUnassigned, internalError, invalidVolumegroupref, invalidDriveref, invalidExpansionList, driveNotOptimal, duplicateDrives, numdrivesGroup, capacityConstrained, invalidDriveState, notFlashcacheVol, flashcacheDeleted, flashcacheMaxCapacityExceeded, flashcacheFailed, flashcacheDegradedState.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_add_drives_to_flash_cache(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (FlashCacheReconfigureDrivesDescriptor) – A FlashCacheReconfigureDrivesDescriptor object that identifies the volume group to be expanded, plus the drive or drives to be added to the volume group. All drives specified for this operation must be in the unassigned state initially. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_add_pending_host(system_id, body, **kwargs)[source]¶

This procedure causes the controller to store some or all of the information contained in the PendingHost argument. The information is simply stored and made available for later retrieval (see getPendingHosts procedure); it is not incorporated into the configured topology, and it is not persisted to disk. If the controller determines that the pending definition is an exact match of configured topology elements, it does not store it. It bears pointing out that, for iSCSI, multiple ports belonging to the same initiator may be present in the pending host information - when this happens, the controller creates only a single initiator, no matter how many ports for that initiator are presented. No authentication is performed on this command. Documented return codes: ok, noHeap, internalError, invalidHosttypeString, invalidProtocol.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_add_pending_host(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (PendingHost) – A PendingHost structure that describes the host to be added to the pending topology. It is not considered an error for the PendingHost structure to have a zero-length host label. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_add_pit_consistency_group_member(system_id, body, **kwargs)[source]¶

This procedure will add a new member to a PiT consistency group (create a new PiT group for the member volume to add and add that PiT group to the consistency group). Returns the ref of the new PiT group created and added to the PCG. Documented return codes: ok, invalidProtection, invalidConcatVolMemberLabel, concatVolMemberTooSmall, maxConsistencyGroupMembersExceeded, consistencyGroupArvmBindingConflict, incompatibleRepositorySecurity, pitGroupsFeatureDisabled.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_add_pit_consistency_group_member(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (PITConsistencyGroupAddMemberDescriptorList) – Descriptor for the consistency group member to be added. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	ReturnCodeWithRefList If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_add_snmp_community(system_id, body, **kwargs)[source]¶

This procedure is used to add a known SNMP community string. SNMP GET/SET requests are only allowed for known communities. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_add_snmp_community(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (SNMPCommunityAddDescriptorList) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	ReturnCodeWithRefList If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_add_snmp_trap_destination(system_id, body, **kwargs)[source]¶

This procedure is used to add an SNMP trap destination. Documented return codes: ok, snmpIncompatibleIpv4Address, snmpIncompatibleIpv6Address.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_add_snmp_trap_destination(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (SNMPTrapDestinationAddDescriptorList) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	ReturnCodeWithRefList If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_adopt_all_drives(system_id, **kwargs)[source]¶

This procedure caused the storage array to “adopt” all foreign drives that are eligible to be adopted. Adoption means accepting or incorporating elements of a foreign drive’s configuration database into that of the recipient array. It must be possible for the storage array to match the adoption-candidate drives with ones that are currently being tracked as “not present.” In addition, several other technical criteria must be met in order for the adoption to succeed. Documented return codes: ok, error, noDrivesAdopted, someDrivesAdopted.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_adopt_all_drives(system_id, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_adopt_drive(system_id, body, **kwargs)[source]¶

This procedure caused the storage array to “adopt” a foreign drive that is eligible to be adopted. Adoption means accepting or incorporating elements of a foreign drive’s configuration database into that of the recipient array. It must be possible for the storage array to match the adoption-candidate drive with one that is currently being tracked as “not present.” In addition, several other technical criteria must be met in order for the adoption to succeed. Documented return codes: ok, error.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_adopt_drive(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – A SYMbol reference to the drive that is to be adopted. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_analyze_copy_on_write_repository(system_id, body, **kwargs)[source]¶

This procedure will run an analysis on the metadata contained in a copy-on-write repository to identify possible causes for failure. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_analyze_copy_on_write_repository(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (CoWRepositoryAnalysisRequest) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	CoWRepositoryAnalysisResultsReturned If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_apply_bundle_key(system_id, body, **kwargs)[source]¶

This procedure causes the storage array to be migrated from one feature bundle definition to another, as specified in the BundleKey argument. Documented return codes: error, illegalParam, tryAlternate, internalError, invalidSafeId, controllerInServiceMode, databaseError, invalidBundleKey.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_apply_bundle_key(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (BundleKey) – A key that defines and enables the bundle migration. This key must be obtained from an authorized source in order to be accepted by the array controller. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_assign_disk_pool_ownership(system_id, body, **kwargs)[source]¶

This procedure is used to instruct the controller to transfer ownership of a disk pool and its associated volumes to another controller. Documented return codes: ok, noHeap, notDualActive, tryAlternate, internalError, invalidRequest, iconFailure, cacheSyncFailure, invalidControllerref, invalidVolumegroupref, modesenseError, controllerInServiceMode.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_assign_disk_pool_ownership(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (VolumeGroupOwnershipUpdateDescriptor) – A descriptor that specifies the volume group being modified, and the controller that is to take ownership of the volume group, and thus all volumes defined on the volume group. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_assign_drives_as_hot_spares(system_id, body, **kwargs)[source]¶

This procedure causes the controller to automatically assign the specified number of drives as hot spares, in addition to any previously assigned hot spares. Documented return codes: ok, illegalParam, noHeap, noSparesAssigned, someSparesAssigned, tryAlternate.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_assign_drives_as_hot_spares(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (int) – The number of new hot spare drives to be added to the array’s pool of hot spares. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_assign_specific_drives_as_hot_spares(system_id, body, **kwargs)[source]¶

Instructs the SYMbol Server’s controller to create hot spare drives out of the given drives. Documented return codes: ok, illegalParam, noHeap, noSparesAssigned, someSparesAssigned, tryAlternate, sparesSmallUnassigned.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_assign_specific_drives_as_hot_spares(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (DriveRefList) – A list of drive reference values, which identifies the drives to be assigned as hot spares. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_assign_volume_group_ownership(system_id, body, **kwargs)[source]¶

Instructs the SYMbol Server’s controller to transfer ownership of a volume group and its associated volumes to another controller. Documented return codes: ok, noHeap, notDualActive, tryAlternate, internalError, invalidRequest, iconFailure, cacheSyncFailure, invalidControllerref, invalidVolumegroupref, modesenseError, controllerInServiceMode.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_assign_volume_group_ownership(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (VolumeGroupOwnershipUpdateDescriptor) – A descriptor that specifies the volume group being modified, and the controller that is to take ownership of the volume group, and thus all volumes defined on the volume group. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_assign_volume_ownership(system_id, body, **kwargs)[source]¶

Instructs the SYMbol Server’s controller to transfer ownership of a volume to another controller. Documented return codes: ok, illegalParam, noHeap, notDualActive, tryAlternate, internalError, invalidControllerref, invalidVolumeref, modesenseError, ghostVolume, controllerInServiceMode.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_assign_volume_ownership(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (VolumeOwnershipUpdateDescriptor) – A descriptor that specifies the volume being modified and the controller that is to take ownership of the volume. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_auto_assign_hot_spares(system_id, **kwargs)[source]¶

Automatically assign hot spares Documented return codes: ok, noHeap, noSparesAssigned, someSparesAssigned, noSparesNeeded.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_auto_assign_hot_spares(system_id, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_auto_load_balance_request(system_id, body, **kwargs)[source]¶

This procedure requests an on-demand volume ownership redistribution for load balancing purposes. Documented return codes: ok, autoLoadBalanceUserDisabled, autoLoadBalanceInsufficientStatistics.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_auto_load_balance_request(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (AutoLoadBalanceRequestDescriptor) – Request descriptor specifying details of the load balance request. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_auto_sa_configuration(system_id, **kwargs)[source]¶

Tells the controller to automatically configure the Storage Array. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_auto_sa_configuration(system_id, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

netapp.santricity.api.symbol.b_api module¶

BApi.py

class netapp.santricity.api.symbol.b_api.BApi(api_client=None)[source]¶

Bases: object

symbol_bind_to_controller(system_id, body, **kwargs)[source]¶

This function is used to bind a new connection to a particular controller. If the server is actually a controller itself, the controller will just ensure that its CONTROLLER REF is the same as the one passed in as an argument. If the server is an agent, it will use the CONTROLLER REF argument to determine which locally-attached controller should be used for all further interactions over the RPC connection. Documented return codes: error, illegalParam, noHeap.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_bind_to_controller(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (ControllerDescriptor) – A descriptor value that identifies the controller to which all further requests on this RPC connection should be routed. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

netapp.santricity.api.symbol.c_api module¶

CApi.py

class netapp.santricity.api.symbol.c_api.CApi(api_client=None)[source]¶

Bases: object

symbol_calculate_dve_capacity(system_id, body, **kwargs)[source]¶

Calculates the volume’s maximum capacity after a DVE operation Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_calculate_dve_capacity(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (VolumeExpansionDescriptor) – This object contains information used for a DVE or DCE/DVE combination. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	int If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_cancel_async_mirror_group_role_change(system_id, body, **kwargs)[source]¶

This procedure is used to cancel an Async Mirror Group role change operation. Documented return codes: ok, remoteInternalError, arvmRemoteGroupDoesNotExist, remoteDatabaseError.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_cancel_async_mirror_group_role_change(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (AsyncMirrorGroupRoleChangeCancelDescriptor) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_cancel_base_controller_diagnostic(system_id, **kwargs)[source]¶

Cancels a running base controller diagnostic test and returns the test status. Documented return codes: ok, authFailParam, diagNotRunning.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_cancel_base_controller_diagnostic(system_id, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	FruDiagReturn If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_cancel_cache_backup_device_diagnostic(system_id, **kwargs)[source]¶

Cancels a running cache backup device diagnostic test and returns the test status. Documented return codes: ok, authFailParam, diagNotRunning.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_cancel_cache_backup_device_diagnostic(system_id, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	FruDiagReturn If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_cancel_cache_memory_diagnostic(system_id, **kwargs)[source]¶

Cancels a running cache memory diagnostic test and returns the test status. Documented return codes: ok, authFailParam, diagNotRunning.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_cancel_cache_memory_diagnostic(system_id, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	FruDiagReturn If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_cancel_database_recovery_mode(system_id, **kwargs)[source]¶

This procedure is used to cancel stable store database recovery. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_cancel_database_recovery_mode(system_id, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_cancel_evacuation(system_id, body, **kwargs)[source]¶

This command cancels an evacuation on the referenced drive. Documented return codes: ok, error, illegalParam, noHeap, driveNotExist, tryAlternate, internalError, invalidDriveref, noEvacFound.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_cancel_evacuation(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – The drive on which to cancel an evacuation. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_cancel_host_card_diagnostic(system_id, **kwargs)[source]¶

Cancels a running host card diagnostic test and returns the test status Documented return codes: ok, authFailParam, diagNotRunning.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_cancel_host_card_diagnostic(system_id, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	FruDiagReturn If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_cancel_import(system_id, body, **kwargs)[source]¶

This procedure indicates to the storage array firmware that the client does not want to proceed with a volume group import operation, and therefore the firmware may spin down the drives that were spun up by the get- ImportDependencies procedure. Documented return codes: ok, volumeGroupStateNotValid.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_cancel_import(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – A reference to the volume group for which the import is to be canceled. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_cancel_pending_cgpit_creation(system_id, body, **kwargs)[source]¶

This procedure cancels a Pending PiT Creation for a PiT Consistency Group. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_cancel_pending_cgpit_creation(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – A reference to the PiT Consistency Group for which you want to cancel a pending creation. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_cancel_pending_pit_creation(system_id, body, **kwargs)[source]¶

This procedure cancels a Pending PiT Creation for a PiT Group. This returns the pending PiT creation state back to “none” from either “waiting” or “failed”. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_cancel_pending_pit_creation(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – A reference to the PiT Group for which you want to cancel a pending creation. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_cancel_pit_rollback(system_id, body, **kwargs)[source]¶

This procedure will cancel a rollback on the specified PiT. Documented return codes: ok, repositoryOffline, invalidPitRef.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_cancel_pit_rollback(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – A reference to the PiT rollback to be canceled. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_cancel_raw_data_restore(system_id, body, **kwargs)[source]¶

This procedure cancels a raw data restore operation. Documented return codes: ok, rawdataTransferNotStarted.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_cancel_raw_data_restore(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (RawDataTransferCancelDesc) – The transfer type and controller reference. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_cancel_raw_data_retrieve(system_id, body, **kwargs)[source]¶

This procedure cancels a raw data retrieve operation. Documented return codes: ok, rawdataTransferNotStarted.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_cancel_raw_data_retrieve(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (RawDataTransferCancelDesc) – The raw data transfer type and controller reference. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_cancel_snapshot_rollback(system_id, body, **kwargs)[source]¶

This procedure is used to cancel a snapshot rollback operation. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_cancel_snapshot_rollback(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – A reference to the snapshot on which to cancel the rollback. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_change_async_mirror_group_role(system_id, body, **kwargs)[source]¶

This procedure will change roles on an Async Mirror Group. Documented return codes: ok, rollbackInProgress, arvmGroupHasIncompleteMember, arvmOrphanGroup, remoteInternalError, arvmRemoteGroupNotSecondary, arvmRemoteGroupDoesNotExist, remoteDatabaseError, arvmExpansionSynchronizationInProgress, arvmRoleChangePending, arvmRoleChangeInProgress, arvmMemberStopped.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_change_async_mirror_group_role(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (AsyncMirrorGroupRoleChangeDescriptor) – A reference to the Asynchronous Mirror Group on which to change roles and some change attributes. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_change_mirror_write_mode(system_id, body, **kwargs)[source]¶

Change mirror write mode Documented return codes: ok, illegalParam, noHeap, internalError, iconFailure, invalidVolumeref, ghostVolume, invalidMirrorvol, rvmVersionMismatch, rvmOperNotAllowedOnSec, legacyRvmAsyncModeUnsupported.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_change_mirror_write_mode(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (MirrorWriteModeDescriptor) – This object contains information used for changing the mirror write mode. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_change_synchronization_priority(system_id, body, **kwargs)[source]¶

Change MirrorProxy Synchronization Priority Documented return codes: ok, illegalParam, noHeap, internalError, iconFailure, invalidVolumeref, ghostVolume, invalidMirrorvol.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_change_synchronization_priority(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (MirrorSyncPriorityDescriptor) – This object contains information used for changing the synchronization priority level for a mirror volume. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_clear_async_mirror_group_fault_indication(system_id, body, **kwargs)[source]¶

This procedure will clear a recovery failure posted for a given Async Mirror Group (AMG). Since some AMG needs attention / recovery failure conditions are “sticky” the user has to acknowledge the condition before it is cleared. Documented return codes: ok, arvmOrphanGroup, arvmOrphanMember, faultConditionStillExists.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_clear_async_mirror_group_fault_indication(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (AsyncMirrorGroupFaultIndicationClearDescriptor) – A reference to the Asynchronous Mirror Group with the condition to acknowledge/clear and the type of indication to clear. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_clear_async_mirror_group_member_fault_indication(system_id, body, **kwargs)[source]¶

This procedure will clear a recovery failure posted for a given Async Mirror Group member. Since some mirror member needs attention / recovery failure conditions are “sticky” the user has to acknowledge the condition before it is cleared. Documented return codes: ok, faultConditionStillExists.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_clear_async_mirror_group_member_fault_indication(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (AsyncMirrorGroupMemberFaultIndicationClearDescriptor) – A reference to the Asynchronous Mirror Group member with the condition to acknowledge/clear and the type of indication to clear. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_clear_ddc_needs_attention(system_id, body, **kwargs)[source]¶

This procedure clears the Needs Attention signifying the availability of diagnostic data. The client must specify a correct tag. This procedure does not clears the DDC logs in the controller. Documented return codes: ok, ddcUnavail, invalidDdcTag.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_clear_ddc_needs_attention(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (int) – A DdcTag value identifying the DDC data set that triggered the Needs Attention. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_clear_dpl_core_dump_needs_retrieved(system_id, **kwargs)[source]¶

This procedure is used to clear the flag indicating that a DPL core dump needs to be retrieved without offloading it. Otherwise, the available DPL core dump will remain in controller memory until overwritten by a new DPL core dump. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_clear_dpl_core_dump_needs_retrieved(system_id, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_clear_drive_channel_statistics(system_id, **kwargs)[source]¶

Clear the drive channel cumulative statistic information Documented return codes: ok, error.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_clear_drive_channel_statistics(system_id, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_clear_persistent_registrations(system_id, body, **kwargs)[source]¶

This procedure clears registrations and reservations for specific volumes. A UNIT ATTENTION, RESERVATIONS PREEMPTED condition is established for the former registrants. Documented return codes: ok, noHeap, regDeleteFailed, controllerInServiceMode.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_clear_persistent_registrations(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (AbstractVolRefList) – The list AbstractVolRefList of volumes to be cleared. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_clear_sa_configuration(system_id, **kwargs)[source]¶

Causes the entire configuration of the storage array to be cleared to an initial state. Documented return codes: ok, error, volumeReconfiguring, tryAlternate, controllerInServiceMode.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_clear_sa_configuration(system_id, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_clear_sas_error_statistics(system_id, **kwargs)[source]¶

Clears SAS PHY error statistics for SAS I/O controller and expander devices in the array Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_clear_sas_error_statistics(system_id, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_clear_soc_error_statistics(system_id, body, **kwargs)[source]¶

Set SOC error statistics baseline information Documented return codes: ok, tryAlternate.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_clear_soc_error_statistics(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – A reference to the controller for which statistics are to be cleared on all accessible SOC devices. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_clear_unreadable_sectors(system_id, body, **kwargs)[source]¶

Clears all the unreadable sectors for the given Volume Documented return codes: ok, illegalParam, noHeap, tryAlternate, invalidVolumeref, volumeOffline, usmClearFailed.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_clear_unreadable_sectors(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – This object contains information for the specific volume. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_communication_check(system_id, body, **kwargs)[source]¶

Sending an RVM Communication Check command Documented return codes: ok, illegalParam, noHeap, internalError, invalidVolumeref, ghostVolume, rvmCommStatRecoveredTimeout, rvmCommStatRecoveredDelay, rvmCommStatNotReady, rvmCommStatTimeout, rvmCommStatChannelFailure, rvmCommStatNetworkFailure, rvmCommStatDeviceMissing, rvmCommStatLoginRejected, rvmCommStatLoginFailure, rvmCommStatInvNumSamplesReqd, rvmQuiescenceInProgress, rvmInvalidRemotevol.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_communication_check(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (RemoteCommunicationCheckDescriptor) – This object performs a user requested communication check for a remote volume. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	RemoteCommunicationCheckSampleList If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_configure_pending_host(system_id, body, **kwargs)[source]¶

This procedure is subject to SYMbol authentication. Documented return codes: ok, noHeap, internalError, hosttypeConflict, portConflict, invalidHosttypeString, invalidProtocol, portRemoved, initiatorConflict, initiatorRemoved.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_configure_pending_host(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (PendingHost) – A PendngHost structure describing a host and its related objects. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_continue_raw_data_restore(system_id, body, **kwargs)[source]¶

This procedure is called once to restore each chunk of data, after first calling a startRawDataRestore to notify the controller that it needs to prepare for the restore. On the first call to this procedure, a return code of RETCODE_RAWDATA_TRANSFER_PREPARING indicates that the controller has not completed the preparation, and the first call should be retried. Upon successful completion of the first call (RETCODE_OK), subsequent calls should be made to transfer additional chunks of data, incrementing the sequence number by one for each call. Documented return codes: ok, invalidFile, flashError, invalidTotalsize, rawdataTransferNotStarted, rawdataTransferPreparing, rawdataTransferReadError, rawdataTransferInvalidImage, rawdataTransferCrcError, dbmRestoreWriteError, rawdataBadSeqNum, dbmDbSourceUnavailable, dbmRestoreSourceMismatch.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_continue_raw_data_restore(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (RawDataRestoreContinueDesc) – The controller ref, type of transfer, final sequence number of the transfer, the sequence number of the chunk currently being delivered, and the restore details for the chunk. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	RawDataRestoreResult If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_continue_raw_data_retrieve(system_id, body, **kwargs)[source]¶

This procedure is called for each chunk of raw data to be transferred to the host. The first call must be preceded by a call to startRawDataRetrieve(). Documented return codes: ok, noHeap, invalidFile, flashError, invalidControllerref, invalidTotalsize, rawdataTransferBadType, rawdataTransferNotStarted, rawdataTransferReadError, rawdataBadSeqNum, rawdataTransferUserCancelled.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_continue_raw_data_retrieve(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (RawDataRetrieveContinueDesc) – The controller ref, raw data transfer type and the sequence number for this chunk. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	RawDataRetrieveResult If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_convert_read_only_pit_view_to_read_write(system_id, body, **kwargs)[source]¶

This procedure will convert a read-only view to a read-write view. Documented return codes: ok, viewStopped.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_convert_read_only_pit_view_to_read_write(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (PITViewRWConversionDescriptor) – Descriptor to PiT View to be converted. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_convert_snapshots_to_pit_groups(system_id, body, **kwargs)[source]¶

This procedure will convert all snapshots of a given base volume to PiT groups. Documented return codes: ok, notDisabled, volumeHasVolcopyRelationship, snapConversionTooManySnaps, snapConversionMissingLabel.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_convert_snapshots_to_pit_groups(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (SnapshotConversionDescriptor) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_copy_drive_then_fail(system_id, body, **kwargs)[source]¶

This procedure triggers the copy of an assigned volume group drive to a standby hot spare. Upon successful completion of the copy, the assigned drive is failed and the hot spare becomes an active drive in the volume group, sparing for the failed drive. Documented return codes: ok, error, illegalParam, noHeap, driveNotExist, tryAlternate, internalError, invalidDriveref, invalidRaidlevel, driveNotOptimal, noVolumes, volumeGroupNotExist, volumeGroupReconfiguring, volumeGroupStateNotValid, volumeGroupNotConfigurable, invalidDriveState, volumeGroupReconstructing, volumeGroupUndergoingCopyback, volumeGroupHasNonOptimalVols, drivesNotAvailableForRemoval, evacInProgress, noHotspareAvailable, driveServiceInProgress.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_copy_drive_then_fail(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – The drive on which to perform the operation. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_copy_drive_then_replace(system_id, body, **kwargs)[source]¶

This command will trigger an evacuation from an assigned volume group drive to an unassigned drive and replace the original drive in the volume group with the new one. Documented return codes: ok, error, illegalParam, noHeap, driveNotExist, tryAlternate, internalError, invalidDriveref, invalidRaidlevel, driveNotOptimal, noVolumes, volumeGroupNotExist, volumeGroupReconfiguring, volumeGroupStateNotValid, volumeGroupNotConfigurable, invalidDriveState, volumeGroupReconstructing, volumeGroupUndergoingCopyback, volumeGroupHasNonOptimalVols, drivesNotAvailableForRemoval, evacInProgress, driveServiceInProgress.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_copy_drive_then_replace(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (CopyThenReplaceDescriptor) – Indicates both the drive to replace and the replacement drive. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_create_a_host_port(system_id, body, **kwargs)[source]¶

This procedure creates a new host port having the attributes specified in the input argument. It is a replacement for the deprecated createHostPort procedure. Documented return codes: ok, noHeap, partDupId, partLabelInvalid, partNodeNonexistent, requestFailedDueToPiRestrictions.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_create_a_host_port(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (HostPortCreateDescriptor) – A HostPortCreateDescriptor object containing a set of attributes to assign to the new host port. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	InstanceReturned If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_create_async_mirror_group(system_id, body, **kwargs)[source]¶

This procedure will create an Async Mirror Group (AMG). Documented return codes: ok, invalidWarnThreshold, arvmGroupUserLabelExists, remoteTargetNotFound, arvmFeatureDeactivated, mirrorProtocolMismatch, invalidSyncPriority, invalidRecoveryPointAlertThreshold, invalidSyncAlertThreshold, remoteArvmFeatureDeactivated, remoteArvmFeatureDisabled, arvmRemoteMaxAsyncMirrorGroupsExceeded, arvmInvalidSyncInterval, remoteNoHeap, remoteInternalError, arvmRemoteGroupUserLabelExists, remoteDatabaseError.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_create_async_mirror_group(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (AsyncMirrorGroupCreationDescriptor) – An object that contains all of the required attributes for the new mirror group. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_create_auto_config(system_id, body, **kwargs)[source]¶

Create automatic configuration Documented return codes: tryAlternate.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_create_auto_config(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (AutoConfigCandidateList) – This object contains a list of automatic configuration templates. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_create_cgpit(system_id, body, **kwargs)[source]¶

This procedure will create a new PiT in a consistency group (a PiT of all members in the group). Documented return codes: ok, pitCreatePending, pitGroupsFeatureDisabled.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_create_cgpit(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – Reference to consistency group. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	ReturnCodeWithRefList If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_create_cluster(system_id, body, **kwargs)[source]¶

This procedure causes a new Cluster object to be created and assigned the specified label. After creating a cluster, hosts can be added to it, mappings established, etc. Documented return codes: ok, noHeap, partDupId, partLabelInvalid.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_create_cluster(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – The user-assigned label to be used for the new cluster. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	ReturnCodeWithRef If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_create_disk_pool(system_id, body, **kwargs)[source]¶

This procedure is used to create an empty disk pool. Documented return codes: ok, error, illegalParam, noHeap, driveNotExist, internalError, invalidLabel, prohibitedByMdtRestrictions, invalidDriveState, raid6FeatureUnsupported, raid6FeatureDisabled, invalidSecurity, noFdeDrives, invalidCriticalThreshold, exceedDiskPoolLimit, exceedDiskPoolCapacity, exceedMaxVolumeCapacity.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_create_disk_pool(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (DiskPoolCreationDescriptor) – Information about the intended disk pool. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_create_flash_cache(system_id, body, **kwargs)[source]¶

This procedure creates a Volume Group and two RAID Volumes to be used for flash cache. Uses the VolumeCandidate for the RAID Volume creation and assigns labels as given. The capacity in the VolumeCandidate is split between the two RAID Volumes. A High Level Volume is also created to reference the RAID Volumes. Documented return codes: ok, error, illegalParam, noHeap, driveNotExist, driveNotUnassigned, internalError, invalidLabel, maxVolumesExceeded, numVolumesGroup, driveTypeMismatch, flashcacheAlreadyExists, flashcacheFeatureDisabled, flashcacheMaxCapacityExceeded, flashcacheMaxLimitExceeded, flashCacheFdeEnablementDisallowed.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_create_flash_cache(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (FlashCacheCreationDescriptor) – The attributes for creation of a flash cache object. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_create_flash_cache_analytics(system_id, body, **kwargs)[source]¶

This procedure creates a zero size FlashCache for performing analytics. It creates a flashcache with no repository to allow collection of projected cache hits during I/O. Documented return codes: ok, error, illegalParam, internalError, invalidLabel, flashcacheAlreadyExists.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_create_flash_cache_analytics(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (FlashCacheAnalyticsCreationDescriptor) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_create_host(system_id, body, **kwargs)[source]¶

This procedure causes a new Host object to be created using the parameters in the creation descriptor argument. After creating a host, host ports can be added to it, mappings established, etc. Documented return codes: ok, noHeap, partDupId, partLabelInvalid, partNodeNonexistent, partLunCollision.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_create_host(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (HostCreationDescriptor) – A HostCreationDescriptor object that contains all required attributes for the new Host object. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	ReturnCodeWithRef If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_create_host_port(system_id, body, **kwargs)[source]¶

This procedure causes a new HostPort object to be created using the parameters in the creation descriptor argument. After creating a host, host ports can be added to it, mappings established, etc. This procedure does not work for iSCSI. Documented return codes: ok, noHeap, partDupId, partLabelInvalid, partNodeNonexistent, requestFailedDueToPiRestrictions.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_create_host_port(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (HostPortCreationDescriptor) – A HostPortCreationDescriptor object that contains all required attributes for the new HostPort object. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	ReturnCodeWithRef If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_create_initiator(system_id, body, **kwargs)[source]¶

This procedure creates a new initiator object. Documented return codes: ok, requestFailedDueToPiRestrictions.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_create_initiator(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (InitiatorCreationDescriptor) – An InitiatorCreationDescriptor object that contains all required properties for the new Initiator object. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	InstanceReturned If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_create_key_value_tag(system_id, body, **kwargs)[source]¶

This procedure is utilized to add new key-value tags to the persistent memory so they can be used for application awareness. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_create_key_value_tag(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (KeyValueTagCreationDescriptorList) – The input is an array of key-value descriptors. The content of each is two opaque, fixed length byte arrays. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	ReturnCodeWithRefList If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_create_lock_key(system_id, body, **kwargs)[source]¶

This procedure creates a new lock key for the array, but does not commit the key to the drives. There must be at least one FDE capable drive present on the array. Documented return codes: ok, noFdeDrives, rekeyInProgress.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_create_lock_key(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (KeyIDInfo) – This is used to generate the WrappedLockKey that this procedure returns. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	WrappedLockKeyReturn If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_create_lun_mapping(system_id, body, **kwargs)[source]¶

This procedure causes a new LUNMapping object to be created using the parameters in the creation descriptor argument. Once this mapping is created, it provides a new LUN-to-volume mapping for I/O accesses from the specified entities to a given volume. Documented return codes: ok, noHeap, partVolumeNonexistent, partLunCollision, partMappingNonexistent, partNoHostports, partIsUtmLun, tooManyPartitions, ghostVolume, cannotMapVolume, partPiIncapable.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_create_lun_mapping(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (LUNMappingCreationDescriptor) – A LUNMappingCreationDescriptor object that contains all required attributes for the new LUNMapping object. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	ReturnCodeWithRef If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_create_metadata_volume(system_id, body, **kwargs)[source]¶

Create a metadata volume Documented return codes: raid6FeatureDisabled.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_create_metadata_volume(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (MetadataVolCreationDescriptor) – A MetadataVolCreationDescriptor object that contains all required attributes for the new MetadataVolume object. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_create_mirror(system_id, body, **kwargs)[source]¶

Create a Mirror Documented return codes: ok, illegalParam, noHeap, volumeNotExist, tryAlternate, internalError, iconFailure, invalidVolumeref, ghostVolume, metadataVolNonexistent, rvmFeatureDisabled, maxMirrorsExceeded, invalidMirrorCandidateVol, remoteMaxMirrorsExceeded, remoteRvmFeatureDisabled, remoteMetadataVolNonexistent, remoteInvalidCfgGen, rvmSpmError, remoteAuthFailPassword, rvmVersionMismatch, rvmRemoteArrayError, rvmCommunicationError, mirrorProtocolMismatch, remoteMaxTotalMirrorsPerArrayExceeded, legacyRvmAsyncModeUnsupported.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_create_mirror(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (MirrorCreationDescriptor) – A MirrorCreationDescriptor object that contains all required attributes for the new Mirror Volume object. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_create_pit(system_id, body, **kwargs)[source]¶

This procedure will create a new PiT in one or more existing PiT Group(s). Max list size is 64 PiT Groups. Documented return codes: ok, invalidPitGroupRef, maxPitsPerGroupExceeded, maxPitsExceeded, pitGroupInConsistencyGroup, alternateRequiredForOperation, pitCreatePending, pitGroupsFeatureDisabled.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_create_pit(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (PITGroupRefList) – Structure containing a list of PiT groups. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	ReturnCodeWithRefList If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_create_pit_consistency_group(system_id, body, **kwargs)[source]¶

This procedure will create a new PiT consistency group. Documented return codes: ok, invalidRollbackPriority, invalidWarnThreshold, invalidPitConsistencyGroupLabel, invalidPitAutoDeleteLimit, invalidPitRepositoryFullPolicy, maxConsistencyGroupsExceeded, pitGroupsFeatureDisabled.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_create_pit_consistency_group(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (PITConsistencyGroupCreationDescriptor) – Descriptor for the consistency group to be created. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	ReturnCodeWithRef If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_create_pit_consistency_group_view(system_id, body, **kwargs)[source]¶

This procedure will create a View on the specified PiTs in a Consistency Group. Documented return codes: ok, incompatibleMemberVol, alternateRequiredForOperation, mustSpecifyExistingVolumes, pitGroupsFeatureDisabled.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_create_pit_consistency_group_view(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (PITConsistencyGroupViewCreationDescriptor) – An object containing all of the attributes required to create a PiT Consistency Group View. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	ReturnCodeWithRef If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_create_pit_group(system_id, body, **kwargs)[source]¶

This procedure will create a new PiT Group. Documented return codes: ok, invalidBasevol, invalidRollbackPriority, invalidWarnThreshold, baseVolumeFailed, invalidProtection, invalidPitGroupLabel, invalidPitAutoDeleteLimit, invalidPitRepositoryFullPolicy, invalidConcatVolMemberLabel, concatVolMemberTooSmall, maxPitGroupsPerBaseExceeded, maxPitGroupsExceeded, incompatibleMemberVol, incompatibleRepositorySecurity, pitGroupsFeatureDisabled.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_create_pit_group(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (PITGroupCreationDescriptor) – Structure containing Pit group creation data. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	ReturnCodeWithRef If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_create_pit_view(system_id, body, **kwargs)[source]¶

This procedure will create a new PiT View. Documented return codes: ok, invalidWarnThreshold, invalidProtection, invalidConcatVolMemberLabel, concatVolMemberTooSmall, invalidPitRef, maxViewsPerPitExceeded, maxViewsExceeded, maxMappableVolumesExceeded, pitInConsistencyGroup, incompatibleMemberVol, incompatibleRepositorySecurity, pitGroupsFeatureDisabled.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_create_pit_view(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (PITViewCreationDescriptor) – Structure containing information about the PiT View to create. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	ReturnCodeWithRef If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_create_sa_port_group(system_id, body, **kwargs)[source]¶

Creates a new SAPortGroup & returns its ref. If a group by that name already exists, returns its ref.. OBSOLETE: Any call to createSAPortGroup will get a return status indicating the command is obsolete. No alternative procedure is available. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_create_sa_port_group(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	ReturnCodeWithRef If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_create_schedule_list(system_id, body, **kwargs)[source]¶

This procedure is used to create a list of schedules. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_create_schedule_list(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (ScheduleCreationDescriptorList) – A list of schedule creation descriptors. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	ReturnCodeWithRefList If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_create_snapshot(system_id, body, **kwargs)[source]¶

Create a snapshot volume of a given base. Documented return codes: ok, error, illegalParam, noHeap, driveNotExist, driveNotUnassigned, tryAlternate, maxVolumesExceeded, partitionsDisabled, maxSnapsPerBaseExceeded, maxSnapsExceeded, invalidBasevol, snapshotFeatureDisabled, numVolumesGroup, ghostVolume, invalidRepositoryLabel, invalidSnapLabel, invalidWarnThreshold, repositoryTooSmall, baseVolumeFailed, baseVolumeOffline, baseVolumeFormatting, raid6FeatureUnsupported, raid6FeatureDisabled, invalidProtection.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_create_snapshot(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (SnapshotCreationDescriptor) – This object contains information about how a new snapshot volume is to be created including the size of the repository, the repository utilization warning threshold and the REPOSITORY full policy. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_create_thin_volume(system_id, body, **kwargs)[source]¶

This procedure creates a new Thin Provisioned Volume. Documented return codes: ok, error, illegalParam, noHeap, volumeNotExist, internalError, invalidVolumeref, invalidLabel, maxVolumesExceeded, invalidWarnThreshold, repositoryTooSmall, invalidConcatVolMemberLabel, illegalVolume, invalidRepositoryCapacity, invalidProvisionedCapacityQuota, invalidExpansionPolicy, invalidVirtualCapacity, maxThinVolumesExceeded.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_create_thin_volume(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (ThinVolumeCreationDescriptor) – An object containing all of the required attributes for a Thin Provisioned Volume. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_create_volume(system_id, body, **kwargs)[source]¶

This procedure causes a new volume to be created based on parameters provided by the caller in the argument structure. Note that a key parameter is a VolumeCandidate object that was previously returned by the controller as the result of a getVolumeCandidates operation. The user must select one such candidate, and then supply further information about the desired attributes of the volume when calling this procedure. Documented return codes: ok, error, illegalParam, noHeap, driveNotExist, driveNotUnassigned, tryAlternate, invalidSegmentsize, invalidLabel, maxVolumesExceeded, cannotFormatVolume, controllerInServiceMode, volumeGroupReconstructing, volumeGroupUndergoingCopyback, raid6FeatureUnsupported, raid6FeatureDisabled, invalidSecurity, noFdeDrives, volumeGroupSecure.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_create_volume(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (VolumeCreationDescriptor) – A VolumeCreationDescriptor object that provides attributes and properties of the volume to be created. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_create_volume_group(system_id, body, **kwargs)[source]¶

Create an empty VolumeGroup Documented return codes: ok, invalidSecurity, noFdeDrives.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_create_volume_group(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (VolumeGroupCreationDescriptor) – A VolumeGroupCreationDescriptor structure containing the volume group creation parameters. The information about the volume group drive composition, RAID level, etc. is conveyed in an embedded VolumeCandidate structure. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_create_workload(system_id, body, **kwargs)[source]¶

This procedure is utilized to add new application awareness workloads to persistent memory. The workload objects are created but do not as yet have Key-Value Tags associated to them. That requires calling the setKeyValueTagMapping procedure. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_create_workload(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (WorkloadCreationDescriptorList) – A list of the WorkloadCreationDescriptors used as an input to the createWorkload procedure. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	ReturnCodeWithRefList If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_create_workload_volume_mapping(system_id, body, **kwargs)[source]¶

This procedure creates the mappings between the list of workloads and volumes specified by the input descriptor. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_create_workload_volume_mapping(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (WorkloadVolumeCreateMappingDescriptorList) – The input descriptor is a list of workload and volume pairs, each pair is to be mapped. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

netapp.santricity.api.symbol.d_api module¶

DApi.py

class netapp.santricity.api.symbol.d_api.DApi(api_client=None)[source]¶

Bases: object

symbol_deactivate_discrete_time_series(system_id, body, **kwargs)[source]¶

This procedure deactivates the discrete time series statistical streams Documented return codes: ok, error, illegalParam, invalidRequest.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_deactivate_discrete_time_series(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (int) – A StatStreamId object that identifies the discrete time series to deactivate. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_deactivate_fibre_channel_check_point_based_async_mirroring(system_id, **kwargs)[source]¶

This procedure will disable mirroring over Fibre Channel (freeing up dedicated channel). Documented return codes: ok, arvmAsyncMirrorGroupPresent.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_deactivate_fibre_channel_check_point_based_async_mirroring(system_id, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_deactivate_histogram(system_id, body, **kwargs)[source]¶

This procedure deactivates a histogram statistics set, given a stream ID. Documented return codes: ok, error, illegalParam, invalidRequest.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_deactivate_histogram(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (int) – A StatStreamId object that identifies the histogram set to deactivate. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_deactivate_mirroring(system_id, **kwargs)[source]¶

Deactivate Remote Mirroring Documented return codes: ok, illegalParam, noHeap, tryAlternate, internalError, iconFailure, mirrorsPresent, rvmFibreError.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_deactivate_mirroring(system_id, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_deassign_drives_as_hot_spares(system_id, body, **kwargs)[source]¶

This procedure causes the drives specified by the argument to be deassigned as hot spares. They will be returned to the pool of unassigned drives, and thus be added to the unconfigured capacity pool of the storage array. Note that a hot spare drive cannot be deassigned if it is currently in use, sparing for a failed drive. Documented return codes: ok, illegalParam, tryAlternate, noSparesDeassigned, someSparesDeassigned.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_deassign_drives_as_hot_spares(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (DriveRefList) – A list of DriveRef values that identifies all drives to be affected by this operation. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_delete_async_mirror_group(system_id, body, **kwargs)[source]¶

This procedure will delete an Async Mirror Group (AMG). Documented return codes: ok, arvmGroupDoesNotExist, arvmGroupNotEmpty, remoteInternalError, remoteDatabaseError, arvmRemoteGroupNotEmpty, remoteTryAlternate, arvmOnlyLocalAmgDeleted.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_delete_async_mirror_group(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (AsyncMirrorGroupDeletionDescriptor) – An object containing all of the required attributes to delete an Asynchronous Mirror Group. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_delete_async_mirror_group_incomplete_member(system_id, body, **kwargs)[source]¶

This procedure is used to clean up a mirror “place holder.” Documented return codes: ok, invalidIncompleteMemberRef, arvmGroupNotSecondary, remoteInternalError, arvmRemoteMirrorMemberDoesNotExist, arvmRemoteGroupDoesNotExist, remoteDatabaseError.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_delete_async_mirror_group_incomplete_member(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – An object with all of the required attributes to delete an incomplete member of an Asynchronous Mirror Group. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_delete_cgpit(system_id, body, **kwargs)[source]¶

This procedure will delete a PiT in one or more members of a consistency group. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_delete_cgpit(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (PITConsistencyGroupPITDeletionDescriptor) – Structure containing information about the consistency group PiT to delete. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_delete_client_mgmt_records_no_password(system_id, body, **kwargs)[source]¶

This procedure deletes a range of (i.e. one or more) specified MgmtClientRecords. Documented return codes: ok, noHeap, volumeNotExist, databaseError.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_delete_client_mgmt_records_no_password(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (MgmtClientRecordDeleteDescriptor) – The MgmtClientRecordDeleteDescriptor value. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_delete_cluster(system_id, body, **kwargs)[source]¶

This procedure causes the Cluster object identified by the argument value to be deleted from the Storage Partitions configuration. Documented return codes: ok, partNodeNonexistent.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_delete_cluster(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – The ClusterRef value for the cluster to be deleted. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_delete_disk_pool(system_id, body, **kwargs)[source]¶

This procedure is used to delete a disk pool and all volumes in that pool. Documented return codes: ok, diskPoolNotEmpty.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_delete_disk_pool(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – A reference to the volume group to be deleted. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_delete_flash_cache(system_id, body, **kwargs)[source]¶

This procedure deletes the High Level Volume, the RAID Volumes on the SSD, and disables flash caching on any associated user volumes. Documented return codes: ok, error, noHeap, internalError, invalidVolumeref, notFlashcacheVol, flashcacheDeleted.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_delete_flash_cache(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – A reference to the flash cache object to delete. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_delete_host(system_id, body, **kwargs)[source]¶

This procedure causes the Host object identified by the argument value to be deleted from the Storage Partitions configuration. Documented return codes: ok, partNodeNonexistent.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_delete_host(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – The HostRef value for the host to be deleted. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_delete_host_port(system_id, body, **kwargs)[source]¶

This procedure causes the HostPort object identified by the argument value to be deleted from the Storage Partitions configuration. Documented return codes: ok, partNodeNonexistent.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_delete_host_port(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – The HostPortRef value for the host port to be deleted. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_delete_initiator(system_id, body, **kwargs)[source]¶

This procedure deletes an initiator object. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_delete_initiator(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – A ScsiNodeRef object that identifies the initiator to delete. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_delete_key_value_tag(system_id, body, **kwargs)[source]¶

This procedure removes from the array the specified key-value tags. It is an error to remove in-use key-value tags. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_delete_key_value_tag(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (KeyValueTagRefList) – The input identifies the key-value pairs to be deleted from the array. Unknown references are ignored. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_delete_key_value_tag_mapping(system_id, body, **kwargs)[source]¶

This procedure removes from the specified volumes all references to specific Key-Value tags. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_delete_key_value_tag_mapping(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (KeyValueTagMappingDeletionDescriptorList) – The input is a list of references to Volumes (or Workloads). For each in the list, all references to Key-Value tags are deleted. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_delete_lun_mapping(system_id, body, **kwargs)[source]¶

This procedure causes the LUNMapping object identified by the argument value to be deleted from the Storage Partitions configuration. Documented return codes: ok, partNodeNonexistent.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_delete_lun_mapping(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – The LUNMappingRef value for the mapping to be deleted. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_delete_mgmt_client_records(system_id, body, **kwargs)[source]¶

This procedure deletes a range of (i.e. one or more) specified MgmtCleintRecords. Documented return codes: ok, noHeap, volumeNotExist, databaseError.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_delete_mgmt_client_records(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (MgmtClientRecordDeleteDescriptor) – The MgmtClientRecordDeleteDescriptor value. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_delete_pit(system_id, body, **kwargs)[source]¶

This procedure will delete one or more PiTs. Documented return codes: ok, rollbackInProgress, invalidPitRef, notOldestPit, pitInConsistencyGroup.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_delete_pit(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (PITRefList) – Structure containing a list of PiTs. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_delete_pit_consistency_group(system_id, body, **kwargs)[source]¶

This procedure will delete an existing PiT consistency group, all of the child PiT groups and their PiTs and associated ERVs. All associated views are stopped. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_delete_pit_consistency_group(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (PITConsistencyGroupDeletionDescriptor) – Descriptor for the consistency group to be deleted. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_delete_pit_consistency_group_view(system_id, body, **kwargs)[source]¶

This procedure will delete the specified PITConsistencyGroupView. Documented return codes: ok, operationFailedVolumeCopyClone.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_delete_pit_consistency_group_view(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (PITConsistencyGroupViewDeletionDescriptor) – An object containing all of the attributes required to delete a PiT Consistency Group View. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_delete_pit_group(system_id, body, **kwargs)[source]¶

This procedure will delete a PiT Group. Documented return codes: ok, rollbackInProgress, invalidPitGroupRef, pitGroupInConsistencyGroup, operationFailedVolumeCopyClone.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_delete_pit_group(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (PITGroupDeletionDescriptor) – Structure containing PiT group reference data. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_delete_pit_view(system_id, body, **kwargs)[source]¶

This procedure will delete an existing PiT View. Documented return codes: ok, operationFailedVolumeCopyClone.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_delete_pit_view(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (PITViewDeletionDescriptor) – Structure containing information about the PiT View to delete. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_delete_sa_port_group(system_id, body, **kwargs)[source]¶

Removes all SAPorts from an SAPortGroup, and deletes the group. OBSOLETE: Any call to deleteSAPortGroup will get a return status indicating the command is obsolete. No alternative procedure is available. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_delete_sa_port_group(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_delete_schedule_list(system_id, body, **kwargs)[source]¶

This procedure will delete a list of schedules. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_delete_schedule_list(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (ScheduleRefList) – A list of schedule references. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_delete_snapshot(system_id, body, **kwargs)[source]¶

Deletes the snapshot volume identified by the input argument. All data on the volume is lost and all resources associated with maintaining the snapshot are released. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_delete_snapshot(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – A SYMbol reference to the snapshot volume that is to be deleted. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_delete_volume(system_id, body, **kwargs)[source]¶

This procedure is used to delete a Thin Volume. The procedure has been deprecated for deleting RAID Volumes - it has been replaced by the procedure deleteVolumeFromGroup. Documented return codes: ok, illegalParam, noHeap, volumeReconfiguring, reservationConflict, internalError, volumeFormatting, invalidVolumeref, volumeOffline, repositoryOffline, repositoryReconfiguring, rollbackInProgress, repositoryMissing, volumeHasMirrorRelationship, volumeInUse.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_delete_volume(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – The value of the AbstractVolRef for the volume to be deleted. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_delete_volume_from_group(system_id, body, **kwargs)[source]¶

This procedure deletes the volume referenced by the input argument. The procedure allows the caller to specify which behavior is desired for the case of deleting the last volume in the volume group - either delete or retain the volume group. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_delete_volume_from_group(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (VolumeDeletionDescriptor) – A VolumeDeletionDescriptor which contains (1) a reference to the volume to delete and (2) a boolean indicator, which indicates whether to delete or retain the volume group when the last volume in the group is deleted. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_delete_volume_group(system_id, body, **kwargs)[source]¶

Delete VolumeGroup and all Volumes in that group Documented return codes: ok, volumeInUse.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_delete_volume_group(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – A reference to the volume group that is to be deleted. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_delete_workload(system_id, body, **kwargs)[source]¶

This procedure removes the specified application awareness workloads. It is not an error to remove in-use (association mapped) workloads. All association mappings for the workload are removed including any KeyValueTag mappings. The actual KeyValueTag records are not deleted. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_delete_workload(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (WorkloadRefList) – A list of SYMbol application awareness workload references. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_delete_workload_volume_mapping(system_id, body, **kwargs)[source]¶

This procedure deletes the specified workload to volume mappings. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_delete_workload_volume_mapping(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (WorkloadVolumeDeleteMappingDescriptorList) – A list of unique identifiers to the workload to volume mappings to be deleted. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_disable_asup(system_id, **kwargs)[source]¶

This procedure is used to disable Autosupport. Documented return codes: ok, notImplemented.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_disable_asup(system_id, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_disable_external_kms(system_id, body, **kwargs)[source]¶

Disables external KMS. Documented return codes: ok, externalKmsNotEnabled, cannotDisableNoKey, externalKmsDisabledNoKey.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_disable_external_kms(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	WrappedLockKeyReturn If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_disable_feature(system_id, body, **kwargs)[source]¶

Disable a single add-on(optional feature Documented return codes: ok, error, invalidSafeCapability, disableNotPermitted.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_disable_feature(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – The Capability value for the “premium” feature to be disabled. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_disable_feature_by_ref(system_id, body, **kwargs)[source]¶

This procedure disables a feature. Documented return codes: uninitialized, ok, error, illegalParam, noHeap, disableNotPermitted, disableEvaluationFeatureNotPermitted, invalidFeatureref.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_disable_feature_by_ref(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – A reference to the feature to disable. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_disable_flash_cache_volume(system_id, body, **kwargs)[source]¶

This procedure deletes the proxy and turns off flash cache volume attributes on the referenced user volume. Documented return codes: ok, error, illegalParam, noHeap, volumeNotExist, internalError, invalidVolumeref, notFlashcacheVol, flashcacheDeleted.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_disable_flash_cache_volume(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – A reference to the volume to disable. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_disable_snapshot(system_id, body, **kwargs)[source]¶

This procedure will disable (stop) the indicated snapshot volume. Documented return codes: ok, illegalParam, noHeap, tryAlternate, internalError, invalidVolumeref, snapNotAvailable, notDisabled, repositoryOffline, ghostVolume, repositoryMissing, repositoryFailed, baseVolumeFailed, baseVolumeOffline.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_disable_snapshot(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – The SnapshotRef of the snapshot volume on which the operation is to be performed. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_disable_snapshot_collection(system_id, body, **kwargs)[source]¶

This procedure will disable (stop) each snapshot volume identified in the argument list. Validation checks for necessary snapshot-disable preconditions are performed prior to disabling any snapshot; if any of the requested snapshots do not meet the preconditions to be disabled, the entire command will be failed and no snapshots will be disabled. If command validation succeeds for all snapshots in the list, but one or more of the snapshots in the list fails to be disabled, the entire command will be failed and no snapshots will be disabled. Requests to disable an already-disabled Snapshot will be treated as no-ops and will be considered successful. Documented return codes: ok, illegalParam, noHeap, internalError, invalidVolumeref, snapNotAvailable, notDisabled, repositoryOffline, ghostVolume, repositoryMissing, repositoryFailed, baseVolumeFailed, baseVolumeOffline.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_disable_snapshot_collection(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (SnapshotRefList) – A SnapshotRefList structure identifying the snapshot volume that are to be disabled. The list may contain as few as one snapshot reference or up to MAX_SNAPSHOT_COLLECTION_SIZE references. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_disable_volume_protection_information(system_id, body, **kwargs)[source]¶

Disables protection information (PI) usage for the specified volume. Documented return codes: ok, volumeHasSnapshotRelationship, volumeHasMirrorRelationship, volumeHasVolcopyRelationship.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_disable_volume_protection_information(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_discover_controllers(system_id, **kwargs)[source]¶

Returns a DiscoveryResponse object that identifies the storage arrays and controllers known to the RPC server that handles this request. Response also indicates if RPC server is RAID controller or SYMbol RPC UTM agent. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_discover_controllers(system_id, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	DiscoveryResponse If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

netapp.santricity.api.symbol.e_api module¶

EApi.py

class netapp.santricity.api.symbol.e_api.EApi(api_client=None)[source]¶

Bases: object

symbol_enable_asup(system_id, **kwargs)[source]¶

This procedure is used to enable Autosupport. Documented return codes: ok, notImplemented.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_enable_asup(system_id, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_enable_external_kms(system_id, body, **kwargs)[source]¶

Enables external KMS. Documented return codes: ok, externalKmsEnabled, externalKmsFailed, externalKmsNotCompliant, externalKmsTimeout.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_enable_external_kms(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	WrappedLockKeyReturn If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_enable_feature(system_id, body, **kwargs)[source]¶

This procedure causes the “premium” features identified in the feature keys of the argument to be enabled. Documented return codes: ok, error, invalidSafeId, invalidSafeKey, invalidSafeCapability, invalidSafeVersion, perfTierSafeUpgradeDisabled, safeControllerNotSubjectToRaid6, premiumFeatureLimitExceedsMaximum, previouslyEnabledForEval, featureNotKeyable.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_enable_feature(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (FeatureKey) – A key for the “premium” feature to be enabled. This key must be obtained from an authorized source in order to be accepted by the array controller. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_enable_feature_evaluation(system_id, body, **kwargs)[source]¶

Used to start an evaluation of a specified feature using the duration specified for the sub-model ID in the FBDT. Documented return codes: ok, noHeap, invalidSafeCapability, previouslyEnabledForEval, evalNotSupported, invalidCapability.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_enable_feature_evaluation(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_enable_flash_cache_volume(system_id, body, **kwargs)[source]¶

This procedure creates a flash cache proxy linked to the referenced user RAID Volume and the flash cache High Level Volume. The flash cache attribute on the RAID Volume will be turned on. Documented return codes: ok, error, illegalParam, noHeap, volumeNotExist, volumeReconfiguring, tryAlternate, internalError, volumeFormatting, invalidVolumeref, volumeOffline, notFlashcacheVol, flashcacheDeleted, flashCacheInvalidBaseVol.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_enable_flash_cache_volume(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (VolumeFlashCacheDescriptor) – A reference to the user volume to link to the flash cache proxy, and a reference to the flash cache volume. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_establish_volume_copy(system_id, body, **kwargs)[source]¶

This procedure establishes a volume copy. Documented return codes: ok, illegalParam, noHeap, tryAlternate, internalError, iconFailure, invalidCopyPriority, copyIncompatibleSource, copyIncompatibleTarget, copyGhostSource, copyGhostTarget, copyInvalidSourceRef, copyInvalidTargetRef, copyInvalidSourceState, copyInvalidTargetState, copySourceReconfig, copyTargetReconfig, copyTargetTooSmall, copyTargetLimit, maxVolumeCopysExceeded, copySourceReservation, copySourceFormat, copyTargetFormat, volcopyFeatureDisabled, copySourceZeroCapacity, copyApptagMismatch.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_establish_volume_copy(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (VolumeCopyCreationDescriptor) – The VolumeCopyCreationDescriptor for the volume copy. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	ReturnCodeWithRef If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_estimate_pit_rollback_repository_utilization(system_id, body, **kwargs)[source]¶

This procedure will return the amount of repository capacity necessary to perform a rollback operation. Documented return codes: ok, invalidPitRef.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_estimate_pit_rollback_repository_utilization(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – A reference to a PiT (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	PITGroupRollbackUtilizationEstimateReturned If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_expand_concat_volume(system_id, body, **kwargs)[source]¶

This procedure will expand a concatenated volume by adding another member RAID volume. Returns the ref for the new ConcatVolMember added. Documented return codes: ok, invalidProtection, invalidConcatVolMemberLabel, concatVolMemberTooSmall, concatMemberLimitExceeded, invalidMemberVol, memberVolMapped, invalidMemberVolState, incompatibleMemberVol, concatVolumeFailed, cannotExpandConcatMember, repositoryFull, insufficientExpansionSpace, invalidExpansionSize, incompatibleRepositorySecurity.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_expand_concat_volume(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (ConcatVolumeExpansionDescriptor) – A descriptor of the concat volume to be expanded. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	ReturnCodeWithRef If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_expand_thin_volume_virtual_capacity(system_id, body, **kwargs)[source]¶

This procedure will expand a thin volume’s virtual capacity. It does not affect the repository volume’s capacity. Documented return codes: ok, error, illegalParam, noHeap, tryAlternate, internalError, invalidVolumeref, illegalVolume, invalidVirtualCapacity.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_expand_thin_volume_virtual_capacity(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (ThinVolumeExpansionDescriptor) – An object containing all of the attributes necessary to expand a thin volume’s virtual capacity. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_export_lock_key(system_id, body, **kwargs)[source]¶

This procedure returns the WrappedLockKeyReturn union for the array.The WrappedLockKeyReturn contains the WrappedLockKey structure for the array it was exported from. No return codes have been documented for this API!

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_export_lock_key(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – The wrapped pass phrase used to encrypt the lock key. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	WrappedLockKeyReturn If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_export_volume_group(system_id, body, **kwargs)[source]¶

This procedure places the identified volume group in an “exported” state so that its drives may be removed and installed into another array. Documented return codes: ok, volumeGroupHasHotspare, volumeGroupReconfiguring, volumeGroupReconstructing, volumeGroupNotComplete, volumeGroupHasFailedDrives, volumeGroupHasNonOptimalVols, volumeGroupHasMirrorRelationship, volumeGroupHasVolcopyRelationship, volumeGroupHasMirroringMetadata, volumeGroupHasMappedVols, volumeGroupHasReservations, volumeGroupHasIncompatibleDacstores, volumeLimitExceeded, volumeGroupHasUnknownRaidLevel, volumeGroupHasUnsupportedRaidLevel, volumeGroupHasCloneOpportunity, volumeGroupHasInsufficientDrives, volumeGroupHasFailedVols, volumeGroupHasSnapshotRelationship, noNativeSstor, volumeInitializing, exportingDrivesDatabaseResynchronizing, exportingDrivesDatabaseFailed, volumeGroupHasArvmRelationship, volumeGroupHasPitgroupRelationship, volumeGroupHasPitviewRelationship, volumeGroupHasConcatRelationship.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_export_volume_group(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – A SYMbol VolumeGroupRef identifying the volume group to export. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_external_kms_re_key(system_id, body, **kwargs)[source]¶

Used to re-key the array with a new lock key. Documented return codes: ok, externalKmsFailed, externalKmsNotEnabled, externalKmsNotCompliant, externalKmsTimeout.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_external_kms_re_key(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – The wrapped pass phrase used to encrypt the lock key. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	WrappedLockKeyReturn If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

netapp.santricity.api.symbol.f_api module¶

FApi.py

class netapp.santricity.api.symbol.f_api.FApi(api_client=None)[source]¶

Bases: object

symbol_fail_back_volume_ownership(system_id, body, **kwargs)[source]¶

This procedure will perform an immediate fail-back of volume current ownership to the preferred owner. Documented return codes: ok, noHeap.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_fail_back_volume_ownership(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (VolumeOwnershipFailBackRequestDescriptor) – Descriptor containing input parameters for fail back request operation. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_force_disk_pool_to_optimal(system_id, body, **kwargs)[source]¶

This procedure attempts to revive the given disk pool. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_force_disk_pool_to_optimal(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – An object containing all of the required attributes to revive the given disk pool. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_force_volume_group(system_id, body, **kwargs)[source]¶

This procedure applies to a volume group for which successful migration of drives from the source array to the target array could not be completed due to hardware errors. It causes the identified volume group to move to a state called the “forced” state, from which it is still permissible to perform an import operation on the volume group. Documented return codes: ok, volumeGroupHasHotspare, volumeGroupReconfiguring, volumeGroupReconstructing, volumeGroupHasFailedDrives, volumeGroupHasNonOptimalVols, volumeGroupHasMirrorRelationship, volumeGroupHasVolcopyRelationship, volumeGroupHasMirroringMetadata, volumeGroupHasMappedVols, volumeGroupHasReservations, volumeGroupHasIncompatibleDacstores, volumeLimitExceeded, volumeGroupHasUnknownRaidLevel, volumeGroupHasUnsupportedRaidLevel, volumeGroupHasCloneOpportunity, volumeGroupHasInsufficientDrives, volumeGroupHasFailedVols, volumeGroupNotContingent, legacyVg, vgNotForceable, driveSpinUpError, volumeGroupHasIncompatibleDrive.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_force_volume_group(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – A SYMbol VolumeGroupRef identifying the volume group to export. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_force_volume_group_to_optimal(system_id, body, **kwargs)[source]¶

This is a potentially dangerous operation, since it causes data to be made available to the I/O host even though that data may have become corrupted due to device failures that occurred in the past. Documented return codes: ok, error, illegalParam, noHeap, volumeReconfiguring, tryAlternate, background, invalidVolumegroupref.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_force_volume_group_to_optimal(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – The value of the VolumeGroupRef for the volume group that is being restored to the optimal state. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

netapp.santricity.api.symbol.g_api module¶

GApi.py

class netapp.santricity.api.symbol.g_api.GApi(api_client=None)[source]¶

Bases: object

symbol_get_alertable_mel_entries(system_id, body, **kwargs)[source]¶

Allows a client to fetch a set of entries that have the alertable, needs attention, or collect support bundle flag set from the array’s MEL for analysis or display. Documented return codes: ok, error.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_alertable_mel_entries(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (MelExtent) – The range of MEL entries. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	MelEntryList If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_asup_status(system_id, **kwargs)[source]¶

This procedure is used to get the current Autosupport status values. Documented return codes: ok, notImplemented.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_asup_status(system_id, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	AsupStatusReturned If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_async_mirror_group_remote_connections(system_id, body, **kwargs)[source]¶

This procedure returns information on the connections established to a remote array for an existing AsyncMirrorGroup. This will return connection information for both controllers. Documented return codes: ok, notImplemented.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_async_mirror_group_remote_connections(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	ScsiRemoteConnectionsReturned If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_async_mirror_group_sync_progress(system_id, body, **kwargs)[source]¶

This procedure will return sync progress information for Async Mirror Groups and their associated members. Calls to this procedure are valid even when a sync is not running. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_async_mirror_group_sync_progress(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (AsyncMirrorGroupRefList) – A list of Asynchronous Mirror Group references. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	AsyncMirrorGroupSyncProgressListReturned If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_async_mirror_repository_utilization(system_id, body, **kwargs)[source]¶

This procedure will return repository utilization information for async mirror members. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_async_mirror_repository_utilization(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (AsyncMirrorGroupMemberRefList) – A list of Asynchronous Mirror Group member references. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	AsyncMirrorRepositoryUtilizationListReturned If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_async_mirror_sync_statistics(system_id, body, **kwargs)[source]¶

This procedure will return synchronization time statistics for a list of mirror members. Documented return codes: ok, notImplemented.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_async_mirror_sync_statistics(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (AsyncMirrorSyncStatisticsRequestDescriptor) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	AsyncMirrorSyncStatisticsListReturned If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_auto_config_candidates(system_id, body, **kwargs)[source]¶

This procedure automatically gets the configuration candidates. Documented return codes: ok, illegalParam, noHeap, driveNotExist, internalError, invalidSegmentsize, raid6FeatureUnsupported, raid6FeatureDisabled.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_auto_config_candidates(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (AutoConfigTemplateList) – This object contains a list of automatic configuration templates. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	AutoConfigCandidateList If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_base_controller_diagnostic_status(system_id, **kwargs)[source]¶

Retrieves the status of a running, interrupted, or completed base controller diagnostic test. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_base_controller_diagnostic_status(system_id, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	FruDiagReturn If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_cache_backup_device_diagnostic_status(system_id, **kwargs)[source]¶

Retrieves the status of a running, interrupted, or completed cache backup device diagnostic test. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_cache_backup_device_diagnostic_status(system_id, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	FruDiagReturn If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_cache_memory_diagnostic_status(system_id, **kwargs)[source]¶

Retrieves the status of a running, interrupted, or completed cache memory diagnostic test. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_cache_memory_diagnostic_status(system_id, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	FruDiagReturn If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_change_state(system_id, body, **kwargs)[source]¶

This procedure is used by clients to query the controller for indications of state changes that have occurred and which would necessitate that the client refresh its view of the storage array’s state. If no state changes need to be reported, the controller will generally hold this request, without responding, for up to the amount of time specified in the argument. If, at any time during the hold period, a state change occurs, the controller will return immediately with the new configuration generation number and/or MEL sequence number. By using this hanging poll approach, the amount of traffic between the client and the server is reduced to an insignificant level, and yet near-immediate notification of changes is still possible. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_change_state(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (ChangeQueryDescriptor) – A ChangeQueryDescriptor object that identifies the caller’s current understanding of the storage array’s state, along with an indication of the maximum hold time for this request. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	ChangeState If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_channel_diagnostics_results(system_id, **kwargs)[source]¶

This procedure reports the results of drive channel fault isolation diagnostic tests that were initiated by the startChannelDIagnostics procedure. Documented return codes: ok, channelDiagsRunning, channelDiagsResultsPartial, channelDiagsResultsNotAvailable.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_channel_diagnostics_results(system_id, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	ChannelDiagResultsReturned If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_cluster_performance_limitation_values(system_id, body, **kwargs)[source]¶

This procedures returns the performance limitation values for a host cluster. Those values include the limits on the IOPs and throughput (MB/s). The number of IOPs impacted by the performance limits is also returned. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_cluster_performance_limitation_values(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – This procedure takes a cluster reference as an input parameter. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	ClusterPerformanceLimitationValuesReturned If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_controller_debug_information(system_id, body, **kwargs)[source]¶

This procedure replaces the deprecated stateCapture procedure. It returns a single “chunk” of debug information and must be used in a series of like calls in order to retrieve the complete set of debug information. Documented return codes: ok, illegalParam, tryAlternate, noSuchDebugChunk, debugInfoConfigChanged.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_controller_debug_information(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (DebugInfoExtent) – A DebugInfoExtent structure containing three pieces of information: a reference to the controller that is to return the data, a “handle” identifying a single mutually-consistent set of chunks, and a chunk number that identifies the specific chunk to be returned. On the request for the initial chunk (chunk zero), the handle is not significant. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	DebugInfoReturned If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_controller_host_interfaces(system_id, **kwargs)[source]¶

This procedure is used by clients to query the referenced controller for up-to-date information about its host-side I/O interfaces. Since this interface information is highly volatile, the object graph data contains only a point-in-time snapshot of the interface data. This procedure can be used to obtain current information that may not be reflected in the most recent object graph. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_controller_host_interfaces(system_id, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	IOInterfaceTypeDataList If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_controller_host_io_interfaces(system_id, body, **kwargs)[source]¶

NOTE: object graph data may not be the most recent. Documented return codes: ok, tryAlternate.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_controller_host_io_interfaces(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – A reference to the controller for which the I/O interface information is desired. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	ControllerHostIoInterfacesReturned If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_controller_nvsram(system_id, body, **kwargs)[source]¶

This procedure allows a client to fetch the data that resides within a designated region of the controller’s NVSRAM. Note that the NVSRAM data is obtained only from the controller to which this request is directed. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_controller_nvsram(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – An NVSRAMRegionId value that identifies the region whose data is to be retrieved. The caller is allowed to specify that all NVSRAM regions be obtained, if desired. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	NVSRAMRegionList If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_controller_time(system_id, **kwargs)[source]¶

This procedure gets the internal clock from the controllers. The time is expressed in seconds since midnight (GMT) on 1/1/1970. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_controller_time(system_id, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	ControllerTime If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_critical_mel_entries(system_id, body, **kwargs)[source]¶

This procedure allows a client to fetch a set of entries with a priority value of EVENT_PRIORITY_CRITICAL from the storage array’s Major Event Log for analysis or display. If there are less critical MEL events than MEL_MAX_XFER_COUNT, all the critical events will be displayed on the first call. If the client receives a number of critical MEL events that is equal to MEL_MAX_XFER_COUNT, then the user must increment the first sequence number to be the highest sequence number in the list of entries returned and repeat the procedure. This process must be repeated until the number of entries returned is less than MEL_MAX_XFER_COUNT. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_critical_mel_entries(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (MelExtent) – A MelExtent object that provides the sequence number of the first and last MEL entries to be retrieved. All critical entries between these two numbers (inclusive) will be transferred to the caller as the result of the operation. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	MelEntryList If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_ctl_lock_down_info(system_id, **kwargs)[source]¶

Returns a structure containing information about the controller if it is locked down. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_ctl_lock_down_info(system_id, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	LockDownInfoReturned If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_cumulative_statistics_bundle(system_id, body, **kwargs)[source]¶

This procedure returns up to two groups of statistical counters, one per controller, bundled together. A counter group is a set of related statistical counters, accumulated over a period of time, along with the associated base time. Documented return codes: ok, error, illegalParam, invalidRequest.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_cumulative_statistics_bundle(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (CumulativeStatisticsDescriptor) – A CumulativeStatisticsDescriptor structure describing the statistics of interest. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	CumulativeStatisticsBundleReturned If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_cumulative_statistics_bundles(system_id, body, **kwargs)[source]¶

This procedure is used to request a list of bundles of statistical data. The argument describes the statistics being requested. Documented return codes: ok, error, illegalParam, invalidRequest.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_cumulative_statistics_bundles(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (CumulativeStatisticsListDescriptor) – An object containing all of the required elements for the procedure. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	CumulativeStatisticsBundleListReturned If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_dacstore_incompatible_volumes(system_id, body, **kwargs)[source]¶

This procedure gets a list of volumes encroaching the requested Dacstore area. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_dacstore_incompatible_volumes(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (int) – A number representing the size of a Dacstore in bytes. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	AbstractVolRefList If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_database_metadata(system_id, **kwargs)[source]¶

This procedure is used to retrieve stable store database metadata. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_database_metadata(system_id, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	DatabaseMetadataReturned If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_ddc_log(system_id, body, **kwargs)[source]¶

This procedure allows a client to retrieve diagnostic information from the storage array’s diagnostic data capture. The client must specify a correct tag and appropriate chunk number. In case of failure, the client must either (1) retry the current chunk number or (2) discard any partially-received log data and retry from the first chunk number (which is one - zero is not a valid chunk number). Documented return codes: ok, illegalParam, ddcUnavail, invalidDdcTag.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_ddc_log(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (DdcExtent) – A DdcExtent structure specifying the chunk to be retrieved. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	DdcLogDataReturned If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_discrete_time_series_bundle(system_id, body, **kwargs)[source]¶

This returns up to two groups of discrete time series statistics, one per controller Documented return codes: ok, error, illegalParam, invalidRequest.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_discrete_time_series_bundle(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (int) – A StatStreamId object that identifies the discrete time series statistics to return. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	DiscreteTimeSeriesBundleReturned If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_disk_pool_expansion_candidates(system_id, body, **kwargs)[source]¶

This procedure returns a list of drive sets that are candidates for use in expanding the given Disk Pool. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_disk_pool_expansion_candidates(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – A reference to the Disk Pool to be expanded. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	ExpansionCandidatesReturned If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_disk_pool_max_reserved_drive_count(system_id, body, **kwargs)[source]¶

This procedure will return the maximum Reserved Drive Count possible on a disk pool. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_disk_pool_max_reserved_drive_count(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – A reference to the Disk Pool for which you want the maximum reserved drive count. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	DiskPoolMaxReservedDriveCountReturn If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_disk_pool_reduction_drive_count(system_id, body, **kwargs)[source]¶

This procedure calculates the maximum number of drives that can be removed from a disk pool. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_disk_pool_reduction_drive_count(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	DiskPoolReductionDriveCountReturn If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_dpl_core_dump_information(system_id, body, **kwargs)[source]¶

This procedure is used to request the information about a DPL core dump. The parameter is a DPL Core Dump Tag. The value of the tag is unique for each core dump and may be obtained from the DPLCoreDumpData structure in StorageArray. Documented return codes: ok, dplCoreDumpInvalidTag.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_dpl_core_dump_information(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (int) – The integer value of the dplCoreDumpTag for which you are requesting information. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	DPLCoreDumpInfoReturn If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_drive_channel_statistics(system_id, **kwargs)[source]¶

This procedure gets statistical information about all of the drive channels. Documented return codes: ok, error, noHeap.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_drive_channel_statistics(system_id, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	DriveChannelList If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_drive_firmware_download_progress(system_id, **kwargs)[source]¶

This procedure gets the progress of the firmware download. Documented return codes: ok, error, illegalParam, noHeap, tryAlternate, invalidRequest, cacheSyncFailure, downloadInProgress, missingData, quiescenceFailed, allFailed, partialOk.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_drive_firmware_download_progress(system_id, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	DriveFirmwareStatus If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_drive_log_data(system_id, body, **kwargs)[source]¶

This procedure gets the drive’s log sense pages. Documented return codes: ok, noHeap, internalError, invalidDriveref.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_drive_log_data(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – This object contains information identifying all drives that are affected by this operation. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	DriveLogData If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_drive_temperatures(system_id, **kwargs)[source]¶

This procedure retrieves temperature data for drives in the storage array. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_drive_temperatures(system_id, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	DriveTemperatureReturned If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_enclosure_state_capture_data(system_id, body, **kwargs)[source]¶

This procedure will retrieve state capture information from controller and expansion enclosures, including DCMs, if any. Send the command to both controllers if the tray is an RBOD. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_enclosure_state_capture_data(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – The ref corresponding to the enclosure for which the data is requested. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	ReturnCodeWithOpaqueData If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_enclosure_temperatures(system_id, **kwargs)[source]¶

This procedure retrieves temperature data for each thermal sensor in each enclosure in the storage array. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_enclosure_temperatures(system_id, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	TrayTemperatureReturned If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_energy_star_data(system_id, **kwargs)[source]¶

This procedure is used to request Energy Star data from all power supplies. Documented return codes: ok, unsupportedEsmRequest.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_energy_star_data(system_id, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	EnergyStarDataReturn If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_enhanced_ib_statistics(system_id, **kwargs)[source]¶

This procedure returns the InfiniBand statistics, which consists of start-of-day-relative interface statistics and baseline-relative statistics. It supersedes the deprecated getIbStatistics () routine. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_enhanced_ib_statistics(system_id, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	EnhancedIbStatisticsReturned If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_env_card_log_data(system_id, body, **kwargs)[source]¶

This procedure gets the log data for the indicated environmental card. Documented return codes: ok, noHeap, internalError, invalidEsmref.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_env_card_log_data(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – The argument is a component reference indicating the environmental card which is to have its log data returned. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	EnvCardLogDataReturned If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_export_dependencies(system_id, body, **kwargs)[source]¶

This procedure returns a list of volume group export dependencies for the identified volume group. The returned list consists of the input volume group’s immediate export dependencies only. The procedure does not return transitive dependencies. It is up to the caller to create the complete dependency graph through successive calls to this procedure. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_export_dependencies(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – A SYMbol VolumeGroupRef identifying the volume group for which export dependencies are to be reported. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	ExportDependenciesReturned If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_flash_cache_analytics(system_id, body, **kwargs)[source]¶

This procedure retrieves analytics data from the last capture period. It returns the cache hits for various sizes of flash cache. Documented return codes: ok, error, illegalParam, internalError, invalidVolumeref, notFlashcacheVol, flashcacheInvalidAnalyticsState.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_flash_cache_analytics(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	FlashCacheAnalyticsReturned If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_flash_cache_statistics(system_id, body, **kwargs)[source]¶

This procedure is used to retrieve flash cache statistics. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_flash_cache_statistics(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	FlashCacheStatisticsReturned If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_histogram_bundle(system_id, body, **kwargs)[source]¶

This procedure returns up to two groups of histogram statistics, one per controller, Documented return codes: ok, error, illegalParam, invalidRequest.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_histogram_bundle(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (int) – A StatStreamId object that identifies the histogram statistics to return. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	HistogramBundleReturned If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_host_card_diagnostic_status(system_id, **kwargs)[source]¶

Retrieves the status of a running, interrupted, or completed host card diagnostic test. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_host_card_diagnostic_status(system_id, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	FruDiagReturn If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_host_specific_nvsram(system_id, body, **kwargs)[source]¶

This procedure allows the Host Specific NVSRAM region to be read to obtain information for a specific host. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_host_specific_nvsram(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (NVSRAMRegionIdAndHostIndex) – An NVSRAMRegionIDAndHostIndex object that specifies the region ID (in this case 0xF2) and the host index for a specific host. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	NVSRAMRegionList If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_hot_spare_candidates(system_id, body, **kwargs)[source]¶

This procedure returns a list of hot spare candidates with the volume groups that they potentially cover. Documented return codes: ok, noHeap, internalError.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_hot_spare_candidates(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – This object contains information describing the physical drive types supported. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	HotSpareCandidateList If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_hot_spare_coverage(system_id, **kwargs)[source]¶

This procedure returns a list of all hot spare drives and their volume groups. Documented return codes: ok, noHeap, volumeNotExist.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_hot_spare_coverage(system_id, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	HotSpareCoverageList If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_ib_ioc_attributes(system_id, **kwargs)[source]¶

This procedure returns attribute information for each InfiniBand I/O controller that is part of the Infiniband I/O Unit. An InfiniBand I/O Controller is a logical entity defined in the InfiniBand Architecture. It does not correlate one-to-one with a storage array controller Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_ib_ioc_attributes(system_id, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	IbIocAttributesReturned If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_ib_port_partition_tables(system_id, **kwargs)[source]¶

This procedure returns a group of InfiniBand port partition tables, one table for each InfiniBand port of the Infiniband I/O Unit (i.e., storage array). Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_ib_port_partition_tables(system_id, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	IbPortPartitionTablesReturned If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_ib_rdma_channels(system_id, **kwargs)[source]¶

This procedure returns various items of information about InfiniBand RDMA channels that are presently active in the Infiniband I/O Unit (i.e., storage array). Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_ib_rdma_channels(system_id, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	IbRdmaChannelsReturned If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_ib_statistics(system_id, **kwargs)[source]¶

This procedure returns the InfiniBand statistics, which consist of start-of-day-relative interface statistics, baseline-relative interface statistics, target channel adapter statistics, and RDMA channel statistics. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_ib_statistics(system_id, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	IbStatisticsReturned If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_import_dependencies(system_id, body, **kwargs)[source]¶

This procedure returns a list of volume group import dependencies for the identified volume group. The reported information identifies the types of dependencies that exist for the volume group. It is necessary for this procedure to spin up the drives in the volume group so that their configuration databases can be read. An error is returned if the volume group is not in the exported or forced state. Documented return codes: ok, volumeGroupStateNotValid, driveSpinUpError.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_import_dependencies(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – A SYMbol VolumeGroupRef identifying the volume group for which import dependencies are to be reported. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	ImportDependenciesReturned If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_ioc_dump_information(system_id, body, **kwargs)[source]¶

This procedure is used to request information about an IOC Dump. The parameter is an IOC Dump Tag. The value of the tag is unique for each dump and may be obtained from the IOCDumpData structure in StorageArray. Documented return codes: ok, iocDumpInvalidTag.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_ioc_dump_information(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (int) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	IOCDumpInfoReturn If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_iscsi_copper_cable_diagnostics(system_id, body, **kwargs)[source]¶

This procedure will perform diagnostic tests on all channels of a given iSCSI HIC. These diagnostics are dependent on the PHY used on a particular HIC, so they may not be available on all ports of the controller. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_iscsi_copper_cable_diagnostics(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (IscsiCableDiagnosticsDescriptor) – Information used to start iSCSI cable diagnostics. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	IscsiCableDiagnosticsReturn If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_iscsi_negotiation_defaults(system_id, **kwargs)[source]¶

This procedure returns the default values for negotiable settings for sessions and connections. These represent the storage array’s starting point for negotiations. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_iscsi_negotiation_defaults(system_id, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	IscsiNegotiationDefaultsReturned If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_iscsi_sessions(system_id, body, **kwargs)[source]¶

This procedure returns data about active iSCSI sessions. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_iscsi_sessions(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (GetIscsiSessionsFilter) – A GetIscsiSessionsFilter object that indicates that either all or a subset of the session data should be returned. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	IscsiSessionsReturned If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_iscsi_statistics(system_id, body, **kwargs)[source]¶

This procedure returns iSCSI statistical data collected by the storage array. The caller may request either the “raw” counts, which are relative to controller start-of-day, or baseline-relative counters, which are relative to the baseline which was last set using the setIscsiStatisticsBaselilne procedure. If the user has not set a baseline since controller start-of-day, then the time at start-of-day is the default baseline time. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_iscsi_statistics(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – An IscsiStatisticsReportType object that indicates if the reported statistics should be the raw or baseline-relative counters. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	IscsiStatisticsReturned If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_long_lived_ops_progress(system_id, **kwargs)[source]¶

This procedure will report progress on each actively running long-lived operation. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_long_lived_ops_progress(system_id, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	LongLivedOpsProgressReturn If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_lun_mappings(system_id, body, **kwargs)[source]¶

This procedure returns a list of LUN mappings that apply to the object identified by the argument SYMbolRef. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_lun_mappings(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – The SYMbolRef value of the entity for which applicable LUN mappings are to be returned. For example, to find all LUN mappings that apply to a particular Cluster object, the associated ClusterRef would be used as the argument. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	LUNMappings If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_mel_entries(system_id, body, **kwargs)[source]¶

This procedure allows a client to fetch a set of entries from the storage array’s Major Event Log for analysis or display. Note that the MEL_MAX_XFER_COUNT constant specifies that maximum number of entries that can be requested in one operation. If more entries are needed, the client must fetch them iteratively, ensuring that no single request exceeds the transfer limit. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_mel_entries(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (MelExtent) – A MelExtent object that provides the sequence number of the first and last MEL entries to be retrieved. All entries between these two numbers (inclusive) will be transferred to the caller as a result of this operation. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	MelEntryList If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_mel_extent(system_id, **kwargs)[source]¶

This procedure is used to determine the head and tail sequence numbers of entries in the storage array’s Major Event Log. The client can use these values to manage controlled fetching of log entries. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_mel_extent(system_id, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	MelExtent If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_metadata_volume_capacity(system_id, body, **kwargs)[source]¶

This procedure returns the amount of storage required for a metadata volume. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_metadata_volume_capacity(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – The metadata volume type e.g. remote volume mirror metadata. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	int If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_object_graph(system_id, **kwargs)[source]¶

This procedure causes all configuration and state information to be returned to the requester. The information is conveyed in the form of an object graph. The ObjectBundle object contains a set of all known logical and physical components. The reference values within these objects can be analyzed to determine the interrelationships and linkages between the key objects, and thus to establish the true graph-oriented image of the storage array state. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_object_graph(system_id, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	ObjectBundle If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_p_registrations(system_id, **kwargs)[source]¶

This procedure returns a list of persistent registrations on the array. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_p_registrations(system_id, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	PRegistrationList If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_p_registrations_for_volume(system_id, body, **kwargs)[source]¶

This procedure returns a list of the persistent registrations for the specified volume. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_p_registrations_for_volume(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – The AbstractVolRef object for the specific volume. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	PRegistrationList If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_parity_check_progress(system_id, body, **kwargs)[source]¶

This procedure returns an indication of the progress of an explicit parity check operation on a particular volume. This procedure is deprecated. The scanVolume procedure should be used instead. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_parity_check_progress(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – The AbstractVolRef value for the volume whose parity check operation is being queried. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	int If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_pending_hosts(system_id, **kwargs)[source]¶

Documented return codes: ok, noHeap, internalError.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_pending_hosts(system_id, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	CheckedPendingHostListReturned If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_persistent_registrations(system_id, **kwargs)[source]¶

Get the list of persistent registrations on the array OBSOLETE: Any call to getPersistantReservations will get a return status indicating the command is obsolete. Please use the new command getPRegistrations. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_persistent_registrations(system_id, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	PersistentRegistrationList If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_persistent_registrations_for_volume(system_id, body, **kwargs)[source]¶

Get the persistent registrations for the specified volume. The list will contain no more than one PersistentRegistration element. OBSOLETE: Any call to getPersistantReservationsForVolume will get a return status indicating the command is obsolete. Please use the new commands getPRegistrationsForVolume. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_persistent_registrations_for_volume(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	PersistentRegistrationList If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_pit_group_repository_utilization(system_id, body, **kwargs)[source]¶

This procedure will return repository utilization information for PiT groups. Documented return codes: ok, invalidPitGroupRef.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_pit_group_repository_utilization(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (PITGroupRefList) – A list of PiT groups for which to return repository utilization. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	PITGroupRepositoryUtilizationListReturned If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_pit_view_repository_utilization(system_id, body, **kwargs)[source]¶

This procedure will return repository utilization information for PiT Views. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_pit_view_repository_utilization(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (PITViewRefList) – A list of PiT Views for which to return repository utilization. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	PITViewRepositoryUtilizationListReturned If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_product_capabilities(system_id, **kwargs)[source]¶

This procedure retrieves a list of product capabilities supported by the array. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_product_capabilities(system_id, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	ProductCapabilityList If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_psu_firmware_update_progress(system_id, **kwargs)[source]¶

This procedure is used to check the progress of a power supply firmware update operation. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_psu_firmware_update_progress(system_id, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	PSUFirmwareUpdateStatus If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_read_link_status(system_id, body, **kwargs)[source]¶

This procedure returns the Read Link Status information. Documented return codes: ok, dstNotFibre.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_read_link_status(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (RLSCommandDescriptor) – A RLS Command Descriptor that provides the type of RLS command. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	RLSResults If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_recovery_failure_list(system_id, **kwargs)[source]¶

This procedure is used by clients to obtain information about all component or logic failures on the storage array that require some form of recovery action. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_recovery_failure_list(system_id, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	FailureTypeList If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_remote_connections(system_id, body, **kwargs)[source]¶

This procedure returns information on the available connections between two arrays. This can be used prior to creation of an AsyncMirrorGroup to determine if there are wiring or other connection configuration issues between the two arrays. A call to this procedure acts like a ping test between the arrays and returns back information on the connections that succeed. This must be issued to each controller independently and should be called in fibre channel environments after activation of fibre channel remote mirroring. Documented return codes: ok, notImplemented.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_remote_connections(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (InitiatorTargetInitialProperties) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	ScsiRemoteConnectionsReturned If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_repository_utilization(system_id, body, **kwargs)[source]¶

This procedure is used by clients to obtain information about the utilization of the repository volume for selected snapshots. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_repository_utilization(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (SnapshotRefList) – A list of snapshot volume reference values. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	RepositoryUtilizationList If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_sa_data(system_id, **kwargs)[source]¶

This procedure returns an object that contains high-level status information about the storage array as a whole. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_sa_data(system_id, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	SAData If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_sa_port(system_id, body, **kwargs)[source]¶

Retrieves a storage array port. OBSOLETE: Any call to getSAPort will get a return status indicating the command is obsolete. No alternative procedure is available. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_sa_port(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (SAPortGetDescriptor) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	ReturnCodeWithRef If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_sa_view_password_digest(system_id, **kwargs)[source]¶

This procedure is used to retrieve the digest of the view array password and its associated salt value which are saved in the array by the setViewPassword procedure. If the view array password isn’t set, the procedure returns a random salt value and the digest of the salt value message. Documented return codes: ok, adminPasswordNotSet.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_sa_view_password_digest(system_id, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	SAViewPasswordDigestReturned If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_sas_error_statistics(system_id, **kwargs)[source]¶

This procedure returns the SAS PHY error statistics for all SAS devices in the storage array. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_sas_error_statistics(system_id, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	SasStatisticsReturned If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_soc_error_statistics(system_id, body, **kwargs)[source]¶

This procedure returns SOC error statistics. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_soc_error_statistics(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (SocCommandDescriptor) – A SOC command descriptor that indicates the devices for which statistics should be returned. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	SocStatisticsReturned If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_system_attribute_defaults(system_id, **kwargs)[source]¶

This procedure returns the default values for system attributes. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_system_attribute_defaults(system_id, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	SystemAttributeDefaultsReturned If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_thin_volume_consumed_capacity(system_id, body, **kwargs)[source]¶

This procedure will retrieve a thin volume’s Expandable Repository Volume consumed capacity. Documented return codes: ok, noHeap, invalidVolumeref, alternateRequiredForOperation, illegalVolume.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_thin_volume_consumed_capacity(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (ThinVolumeRefList) – A reference to the thin volume for which you want the consumed capacity. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	ThinVolumeConsumedCapacityReturned If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_thin_volume_expansion_history(system_id, body, **kwargs)[source]¶

This procedure will retrieve a thin volume’s repository expansion history. Documented return codes: ok, illegalParam, invalidVolumeref.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_thin_volume_expansion_history(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – A reference to the thin volume for which you want the repository expansion history. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	ThinVolumeRepositoryExpansionHistoryListReturned If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_unconfigured_initiators(system_id, **kwargs)[source]¶

This procedure returns a list of initiators that have been detected by the storage array, but which are not configured into the storage array topology. An initiator is considered unconfigured if it is not associated with a host. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_unconfigured_initiators(system_id, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	UnconfiguredInitiatorsReturned If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_unlabeled_host_ports(system_id, **kwargs)[source]¶

This procedure returns information about host ports whose world-wide names are known to the controller, but which have not been defined as full HostPort objects via the SYMbol interface. Note that you only need to send the request to one of the controllers, and that the same list of unlabeled host ports are returned, regardless of which controller receives the request. This procedure does not apply to iSCSI. The getUnconfiguredInitiators procedure should be used instead. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_unlabeled_host_ports(system_id, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_volume_action_progress(system_id, body, **kwargs)[source]¶

This procedure returns an indication of the extent to which a long-running operation on a volume has completed. The set of supported long-running operations is defined by the VolumeAction enumeration. This procedure can also be called for a snapshot volume. The set of supported long-running operations for snapshot volumes is defined by the SnapshotAction enumeration. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_volume_action_progress(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – The value of the AbstractVolRef for the volume whose long-running operation is being queried. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	VolumeActionProgress If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_volume_candidates(system_id, body, **kwargs)[source]¶

This procedure returns a list of volume candidates that can be used in an ensuing volume creation request. Documented return codes: error, invalidSecurity, noFdeDrives, volumeGroupSecure.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_volume_candidates(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (VolumeCandidateRequest) – A VolumeCandidateRequest descriptor that specifies the type of volume candidates to be returned to the caller. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	VolumeCandidateList If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_volume_copy_source_candidates(system_id, **kwargs)[source]¶

This procedure returns a list of volume source candidates for creating a volume copy. Documented return codes: ok, illegalParam, noHeap, tryAlternate, iconFailure, maxVolumeCopysExceeded, volcopyFeatureDisabled.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_volume_copy_source_candidates(system_id, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	VolumeCopyCandidateList If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_volume_copy_target_candidates(system_id, body, **kwargs)[source]¶

This procedure returns a list of volume target candidates for creating a volume copy. Documented return codes: ok, illegalParam, noHeap, tryAlternate, iconFailure, maxVolumeCopysExceeded, volcopyFeatureDisabled.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_volume_copy_target_candidates(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – An AbstractVolRef descriptor that specifies the source volume for which the target candidates are requested (i.e. the source volume in the candidate copy relationshipu2026 the SYMbol client is requesting valid target volumes to use with this source volume). (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	VolumeCopyCandidateList If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_volume_group_expansion_candidates(system_id, body, **kwargs)[source]¶

The firmware prioritizes the properties of candidates for constructing the return list, subject to the volume group having a given property in the first place. The prioritization and ordering of the list is as follows: Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_volume_group_expansion_candidates(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – A reference to the volume group to which the candidates are to apply. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	ExpansionCandidatesReturned If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_volume_list_for_mirroring(system_id, body, **kwargs)[source]¶

This procedure returns a list of mirror volume candidates that can be used in an ensuing mirror volume creation request. Documented return codes: ok, illegalParam, noHeap, internalError, invalidVolumeref, ghostVolume, metadataVolNonexistent, rvmFeatureDisabled, maxMirrorsExceeded, invalidMirrorCandidateVol, noValidMirrorCandidate, remoteMaxMirrorsExceeded, remoteRvmFeatureDisabled, remoteMetadataVolNonexistent, rvmVersionMismatch, rvmRemoteArrayError, rvmCommunicationError.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_volume_list_for_mirroring(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (MirrorCandidateDescriptor) – A MirrorVolumeCandidateRequest descriptor that specifies the type of mirror volume candidates to be returned to the caller. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	MirrorVolumeCandidateList If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_get_volume_performance(system_id, body, **kwargs)[source]¶

This procedure is used by the client to retrieve performance monitoring data for one or more volumes. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_get_volume_performance(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (AbstractVolRefList) – A list of AbstractVolRef values of the volumes for which the caller wishes to obtain performance monitoring information. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	VolumePerformanceList If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

netapp.santricity.api.symbol.i_api module¶

IApi.py

class netapp.santricity.api.symbol.i_api.IApi(api_client=None)[source]¶

Bases: object

symbol_import_lock_key(system_id, body, **kwargs)[source]¶

This procedure allows a security locked drive to be unlocked. An archived, wrapped and encrypted lock key is imported into the array. In response, the controller attempts to unlock all security-locked drives that have a matching lock key ID. The imported lock key and lock key id become the new array lock key and lock key ID. Documented return codes: ok, notImplemented, noLockedDrives, invalidBlob, unlockFailed, noKeySet.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_import_lock_key(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (LockKeyBlob) – A LockKeyBlob structure that contains the wrapped lock key and the pass phrase used to encrypt the lock key. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_import_volume_group(system_id, body, **kwargs)[source]¶

This procedure causes the identified volume group to be imported, which move it from either the “exported” state or the “forced” state to the “complete” state in which it is fully operable and available for use. Note that “higher-level” volumes (SnapshotVolume, MetadataVolume, VolumeCopy, and MirrorProxyVolume) - but not their underlying RAID volumes - are removed as part of the import. Documented return codes: ok, volumeGroupHasHotspare, volumeGroupReconfiguring, volumeGroupReconstructing, volumeGroupNotComplete, volumeGroupHasFailedDrives, volumeGroupHasNonOptimalVols, volumeGroupHasMirrorRelationship, volumeGroupHasVolcopyRelationship, volumeGroupHasMirroringMetadata, volumeGroupHasMappedVols, volumeGroupHasReservations, volumeGroupHasIncompatibleDacstores, volumeLimitExceeded, volumeGroupHasUnknownRaidLevel, volumeGroupHasUnsupportedRaidLevel, volumeGroupHasCloneOpportunity, volumeGroupHasInsufficientDrives, volumeGroupHasFailedVols, driveSpinUpError, volumeGroupHasIncompatibleDrive, volumeGroupVolumeEncroachesOnDacstore, volumeGroupImportInProgress, drivesNeedToBeSpunUp, noNativeSstor.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_import_volume_group(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – A SYMbol VolumeGroupRef identifying the volume group to export. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_initialize_drive(system_id, body, **kwargs)[source]¶

This procedure causes the specified drive object to be initialized for use in the system. All data on the drive is irretrievably lost as a result of this operation. Only offline drives or drives whose status is DRIVE_STAT_INCOMPATIBLE are candidates for initialization. This procedure implicitly transitions the drive to the online state. Documented return codes: ok, error, illegalParam, noHeap, tryAlternate, invalidDriveref.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_initialize_drive(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – The value of the drive reference for the drive that is to be initialized. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_install_lock_key(system_id, body, **kwargs)[source]¶

Passes an existing lock key for the array and unlocks the disks. Documented return codes: ok, invalidBlob.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_install_lock_key(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (WrappedLockKeyList) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_install_new_lock_key(system_id, body, **kwargs)[source]¶

Passes a new lock key for the array and commits the key to the disks. Documented return codes: ok, invalidBlob, externalKmsNotEnabled, keyNotNeeded, keyInvalidSequence, externalKmsNotCompliant, invalidLockKeyId.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_install_new_lock_key(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (NewLockKey) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_invalidate_staged_controller_firmware(system_id, **kwargs)[source]¶

This procedure invalidates the staged controller firmware. Documented return codes: ok, error, illegalParam, downloadInProgress.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_invalidate_staged_controller_firmware(system_id, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_issue_discrete_lines_test(system_id, **kwargs)[source]¶

This procedure executes the inter-controller discrete line diagnostics test. Documented return codes: ok, error, dltNotCompleted.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_issue_discrete_lines_test(system_id, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_issue_runtime_diagnostics(system_id, body, **kwargs)[source]¶

This procedure is used to start the Runtime Diagnostics. Documented return codes: ok, illegalParam, tryAlternate, diagReadFailure, diagWriteFailure, diagLoopbackError, diagTimeout, diagInProgress, diagNoAlt, diagIconSendErr, diagInitErr, diagModeErr, diagInvalidTestId, diagDriveErr, diagLockErr, diagConfigErr, diagNoCacheMem, diagNotQuiesced, diagUtmNotEnabled.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_issue_runtime_diagnostics(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (RuntimeDiagDescriptor) – A descriptor that specifies the Runtime Diagnostics tests to run. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	RuntimeDiagResults If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

netapp.santricity.api.symbol.l_api module¶

LApi.py

class netapp.santricity.api.symbol.l_api.LApi(api_client=None)[source]¶

Bases: object

symbol_load_controller_firmware(system_id, body, **kwargs)[source]¶

To indicate the end of the iterative download sequence, call this procedure with a zero-length segment size. When the controller receives this end indicator, the controller writes the accumulated firmware image to stable storage (typically flash memory). The controller responds to this procedure call with the appropriate return code, delays for a short period, and then reboots to load and execute the new firmware. Documented return codes: ok, error, busy, illegalParam, noHeap, invalidFile, imageTransferred, fileTooLarge, invalidOffset, overrun, invalidChunksize, invalidTotalsize, downloadNotPermitted, spawnError, voltransferError, invalidDlstate, cacheconfigError, downloadInProgress, controllerInServiceMode.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_load_controller_firmware(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (FirmwareUpdateDescriptor) – A FirmwareUpdateDescriptor object that indicates, among other things, the offset and size of the firmware segment being transferred. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_load_controller_firmware_no_password(system_id, body, **kwargs)[source]¶

Used to download some or all of a new firmware image file to a controller when the authentication password is unavailable. Documented return codes: ok, error, busy, illegalParam, noHeap, invalidFile, imageTransferred, fileTooLarge, invalidOffset, overrun, invalidChunksize, invalidTotalsize, downloadNotPermitted, spawnError, voltransferError, invalidDlstate, cacheconfigError, downloadInProgress, controllerInServiceMode.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_load_controller_firmware_no_password(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (FirmwareUpdateDescriptor) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_load_controller_firmware_on_lockdown(system_id, body, **kwargs)[source]¶

To indicate the end of the iterative download sequence, call this procedure with a zero-length segment size. When the controller receives this end indicator, the controller writes the accumulated firmware image to stable storage (typically flash memory). The controller responds to this procedure call with the appropriate return code, delays for a short period, and then reboots to load and execute the new firmware. Documented return codes: ok, error, busy, illegalParam, noHeap, invalidFile, imageTransferred, fileTooLarge, invalidOffset, overrun, invalidChunksize, invalidTotalsize, downloadNotPermitted, spawnError, voltransferError, invalidDlstate, cacheconfigError, downloadInProgress, controllerInServiceMode.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_load_controller_firmware_on_lockdown(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (FirmwareUpdateDescriptor) – A FirmwareUpdateDescriptor object that indicates, among other things, the offset and size of the firmware segment being transferred. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_load_controller_nvsram(system_id, body, **kwargs)[source]¶

To indicate the end of the iterative download sequence, call this procedure with a zero-length segment size. When the controller receives this end indicator, the controller writes the accumulated NVSRAM image to stable storage (typically flash memory). The controller responds to this procedure call with the appropriate return code, delays for a short period, and then reboots to load and execute the new NVSRAM. Documented return codes: ok, error, busy, illegalParam, noHeap, invalidFile, flashError, fileTooLarge, invalidOffset, overrun, invalidChunksize, invalidTotalsize, downloadNotPermitted, spawnError, downloadInProgress, utmConflict, controllerInServiceMode.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_load_controller_nvsram(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (FirmwareUpdateDescriptor) – A FirmwareUpdateDescriptor object that specifies the size and content of the NVSRAM data to be loaded by the controller. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_load_controller_nvsram_no_password(system_id, body, **kwargs)[source]¶

This procedure is used to download a NVSRAM image file to a controller when the duplex setting gets erroneously inserted into a Native SATA array. In such a situation, none of the native SATA drives will be recognized by the firmware since the IOC will be set to enable the STP (SATA) layer only if the setting is Simplex. The Recovery Action in such a scenario is to download new NVSRAM using this command and boot with it. Documented return codes: ok, error, illegalParam, imageTransferred, fileTooLarge, invalidChunksize, downloadInProgress, controllerInServiceMode.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_load_controller_nvsram_no_password(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (FirmwareUpdateDescriptor) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_load_drive_firmware(system_id, body, **kwargs)[source]¶

Downloads a portion of a new firmware image to a drive in the SYMbol Server. loadDriveFirmware OBSOLETED by implementation of parallel drive firmware download Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_load_drive_firmware(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (DriveFirmwareUpdateDescriptor) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_load_esm_firmware(system_id, body, **kwargs)[source]¶

This procedure is used to download some or all of a new firmware image to the ESM cards in a tray. The argument object specifies tray where the ESMs are located, the size of the firmware segment being downloaded, and the offset of the segment within the overall firmware image. Downloads are accomplished using an iterative approach, where the overall image is segmented and each segment transferred to the controller via a call to this procedure. To indicate the end of the iterative download sequence, this procedure should be called with a zero-length segment size. When this end indicator is received by the controller, the accumulated firmware image will be written to the ESM cards. Documented return codes: ok, error, busy, noHeap, tryAlternate, fileTooLarge, invalidOffset, overrun, invalidChunksize, invalidTotalsize, spawnError, cacheconfigError, downloadInProgress, esmDownloadFailed, esmPartialUpdate, controllerInServiceMode.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_load_esm_firmware(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (ESMFirmwareUpdateDescriptor) – An ESMFirmwareUpdateDescriptor object that indicates the tray to receive the firmware, the offset and size of the firmware segment being transferred. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_load_esm_firmware_on_mismatch(system_id, body, **kwargs)[source]¶

This procedure is used to download a new firmware image to the ESM cards in a tray. This procedure is identical in behavior to loadESMFirmware. with respect to interpretation of the argument and performing the download process. It differs from that command with respect to certain pre-validation checks it performs. In particular, it requires that an ESM firmware mismatch condition exist on the indicated tray before it will proceed with the download. Documented return codes: ok, error, busy, noHeap, tryAlternate, fileTooLarge, invalidOffset, overrun, invalidChunksize, invalidTotalsize, spawnError, cacheconfigError, downloadInProgress, esmDownloadFailed, esmPartialUpdate, controllerInServiceMode, requiredConditionNotPresent.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_load_esm_firmware_on_mismatch(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (ESMFirmwareUpdateDescriptor) – An ESMFirmwareUpdateDescriptor object that indicates the tray to receive the firmware, the offset and size of the firmware segment being transferred. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_load_factory_defaults(system_id, body, **kwargs)[source]¶

This procedure is used to download factory default information to a controller or expansion enclosure. Documented return codes: ok, error, factoryDefaultDownloadFailed, errorWritingToEeprom, factoryDefaultPartialUpdate.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_load_factory_defaults(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (FactoryDefaultsDescriptor) – The factory default data. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

netapp.santricity.api.symbol.m_api module¶

MApi.py

class netapp.santricity.api.symbol.m_api.MApi(api_client=None)[source]¶

Bases: object

symbol_modify_schedule_list(system_id, body, **kwargs)[source]¶

This procedure is used to modify a list of schedules. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_modify_schedule_list(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (ScheduleUpdateDescriptorList) – A list of schedule update descriptors. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_move_host(system_id, body, **kwargs)[source]¶

Changes the Storage Partitions configuration for a Host object by modifying the host’s cluster assignment. Documented return codes: ok, partNodeNonexistent, partLunCollision, requestFailedDueToPiRestrictions.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_move_host(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (SYMbolRefPair) – A SYMbolRefPair object. The itemRef field of the argument is a HostRef that identifies the host being modified, and the containerRef field is a ClusterRef that identifies the cluster to which the host is to be moved. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_move_host_port(system_id, body, **kwargs)[source]¶

Changes the Storage Partitions configuration for a HostPort object by modifying the port’s host assignment. This procedure does not apply for iSCSI . Documented return codes: ok, partNodeNonexistent, partLunCollision, requestFailedDueToPiRestrictions.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_move_host_port(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (SYMbolRefPair) – A SYMbolRefPair object. The itemRef field of the argument is a HostPortRef that identifies the host port being modified, and the containerRef field is a HostRef that identifies the host to which the port is to be moved. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_move_lun_mapping(system_id, body, **kwargs)[source]¶

Move a LUN mapping. Documented return codes: ok, partNodeNonexistent, partLunCollision, partMappingNonexistent, partNoHostports, partIsUtmLun, tooManyPartitions, partPiIncapable.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_move_lun_mapping(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (LUNMappingUpdateDescriptor) – A LUNMappingUpdateDescriptor that provides the new values for the LUN used to access the mapped value, as well as the host/cluster for which the mapping applies. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_move_sa_port(system_id, body, **kwargs)[source]¶

Removes the SA Port ‘itemRef’ from any SA Port Group that it might be in, & moves it to the group ‘containerRef’. If this leaves the previous SAPortGroup empty, the previous SAPortGroup is deleted. OBSOLETE: Any call to moveSAPort will get a return status indicating the command is obsolete. No alternative procedure is available. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_move_sa_port(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (SYMbolRefPair) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

netapp.santricity.api.symbol.p_api module¶

PApi.py

class netapp.santricity.api.symbol.p_api.PApi(api_client=None)[source]¶

Bases: object

symbol_ping_controller(system_id, **kwargs)[source]¶

This procedure simply verifies that the controller is responsive and is operating properly. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_ping_controller(system_id, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_power_cycle_physical_drive(system_id, body, **kwargs)[source]¶

This procedure is used to power cycle an individual physical drive. Documented return codes: ok, driveNotUnassigned, volumeReconfiguring, volumeNotOptimal, downloadInProgress, parityScanInProgress, volumeGroupNotComplete, dpcVolumeGroupNotRedundant, dpcVolumeNotInitialized, dpcExclusiveOperationActive, dpcFormatActive, dpcUnreadableSectorsPresent, dpcPowerCycleAlreadyInProgress, dpcEnclosureHardwareUnsupported, dpcEnclosureFwDownlevel.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_power_cycle_physical_drive(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (PowerCyclePhysicalDriveDescriptor) – The descriptor for the drive to be power cycled. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	PowerCyclePhysicalDriveDataReturn If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_power_down_array(system_id, **kwargs)[source]¶

This command provides a programmatic means of powering off a storage array The operation is performed as gracefully as possible. Once this command is received, all open sockets, except for those that have in-process commands, are closed, meaning that any new SYMbol commands attempted will receive an RPC error. SYMbol commands that are in-process when this command is received are allowed to continue execution. In-process SYMbol commands in the “active” category are guaranteed to complete; In-process commands in the “passive” category may complete, but there is no guarantee. This command returns and reports status just prior to the actual power down event. Authentication is required for this command. Documented return codes: ok, noHeap, background, cacheSyncFailure, quiescenceFailed, controllerInServiceMode.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_power_down_array(system_id, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

netapp.santricity.api.symbol.q_api module¶

QApi.py

class netapp.santricity.api.symbol.q_api.QApi(api_client=None)[source]¶

Bases: object

symbol_quiesce_controller(system_id, body, **kwargs)[source]¶

This procedure is used to put the controller in a quiesced state. Documented return codes: ok, error, illegalParam, invalidControllerref, controllerInServiceMode.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_quiesce_controller(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – The value of the controller that is to be quiesced. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

netapp.santricity.api.symbol.r_api module¶

RApi.py

class netapp.santricity.api.symbol.r_api.RApi(api_client=None)[source]¶

Bases: object

symbol_read_mgmt_client_records(system_id, body, **kwargs)[source]¶

This procedure reads a range of (i.e. one or more) MgmtClient Record objects. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_read_mgmt_client_records(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (MgmtClientRecordReadDescriptor) – The MgmtClientRecordReadDescriptor value. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	MgmtClientRecordReadResult If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_read_unreadable_sector_database(system_id, **kwargs)[source]¶

This procedure returns a list of the known unreadable sectors for the system. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_read_unreadable_sector_database(system_id, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	UnreadableSectorTableInfo If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_recover_async_mirror_group_member(system_id, body, **kwargs)[source]¶

This procedure is used to recover a stopped or failed Async Mirror Group Member. Documented return codes: arvmRecoveryPointDeletionRequired, arvmOnlyPrimaryMemberRemoved, arvmOnlySecondaryMemberRemoved, arvmOrphanGroup, volumeNotAvailable, volumeHasUnreadableSectors, remoteInternalError, arvmRemoteMirrorMemberDoesNotExist, remoteDatabaseError.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_recover_async_mirror_group_member(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – An object containing all of the required attributes to recover an Asynchronous Mirror Group member. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_recover_async_mirror_group_member_delete_recovery_point(system_id, body, **kwargs)[source]¶

This procedure is used to recover a stopped or failed asynchronous mirror group member. Documented return codes: ok, arvmRecoveryPointDeletionRequired, arvmOnlyPrimaryMemberRemoved, arvmOnlySecondaryMemberRemoved, arvmOrphanGroup, volumeNotAvailable, volumeHasUnreadableSectors, remoteInternalError, arvmRemoteMirrorMemberDoesNotExist, remoteDatabaseError, arvmThinVolInitError, arvmRemoteThinVolInitError.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_recover_async_mirror_group_member_delete_recovery_point(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (AsyncMirrorGroupRecoverDescriptor) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_recover_from_miswire(system_id, **kwargs)[source]¶

This procedure is used to tell the controller that corrective action has been taken to recover from a mis-wire condition. The controller will re-enable any SAS Ports that were disabled when a mis-wire was detected. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_recover_from_miswire(system_id, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_recover_volume(system_id, body, **kwargs)[source]¶

This procedure creates a volume using the parameters of a volume that previously existed. Since no data or parity initialization is performed on the volume, the prior data is preserved resulting in a volume that is identical to the previous volume. Documented return codes: maxVolumesExceeded, raid6FeatureUnsupported, raid6FeatureDisabled.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_recover_volume(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (RecoverVolumeDescriptor) – This object contains information on how a recovered volume is to be created. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_recreate_snapshot(system_id, body, **kwargs)[source]¶

This procedure restarts a snapshot volume that was previously created. The snapshot must have been previously disabled for this procedure to succeed. Documented return codes: ok, illegalParam, noHeap, tryAlternate, internalError, invalidVolumeref, snapNotAvailable, notDisabled, snapshotFeatureDisabled, repositoryOffline, ghostVolume, repositoryMissing, repositoryFailed, baseVolumeFailed, baseVolumeOffline, basevolSizeChanged.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_recreate_snapshot(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (SnapshotParamsUpdateDescriptor) – A descriptor object that specifies the various snapshot parameters. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_recreate_snapshot_collection(system_id, body, **kwargs)[source]¶

During snapshot recreation, all affected volumes (snapshots, base, and repository) will be appropriately quiesced; I/O will be resumed to all affected volumes once all snapshots have been successfully restarted. Documented return codes: ok, illegalParam, noHeap, internalError, invalidVolumeref, snapNotAvailable, notDisabled, snapshotFeatureDisabled, repositoryOffline, ghostVolume, repositoryMissing, repositoryFailed, baseVolumeFailed, baseVolumeOffline, basevolSizeChanged.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_recreate_snapshot_collection(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (SnapshotRefList) – A SnapshotRefList structure identifying the snapshot volume that are to be restarted. The list may contain as few as one snapshot reference or up to MAX_SNAPSHOT_COLLECTION_SIZE references. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_refresh_iscsi_dhcp_parameters(system_id, body, **kwargs)[source]¶

This procedure performs a refresh of the DHCP parameters for the iSCSI interface specified by the input argument. The affected parameters are port IP address, subnet mask, and gateway IP address. Documented return codes: ok, manualConfigModeSet.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_refresh_iscsi_dhcp_parameters(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – An Interface reference that identifies the iSCSI interface on which the operation is to be performed. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_refresh_isns_server_location(system_id, **kwargs)[source]¶

This procedure causes the storage array to refresh its idea of the network address information for the iSNS server Documented return codes: background, manualConfigModeSet.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_refresh_isns_server_location(system_id, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_reinitialize_thin_volume(system_id, body, **kwargs)[source]¶

This procedure causes the referenced thin volume to be reinitialized to have no content. Documented return codes: ok, illegalParam, tryAlternate, notImplemented, internalError, invalidVolumeref, repositoryTooSmall, invalidConcatVolMemberLabel, illegalVolume, invalidRepositoryCapacity, invalidProvisionedCapacityQuota, invalidReinitAction, invalidReinitCapacity.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_reinitialize_thin_volume(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (ThinVolumeReinitializeDescriptor) – An object containing all of the required attributes for reinitializing a thin volume. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_release_support_data(system_id, body, **kwargs)[source]¶

This procedure attempts to release a previously acquired Customer Support Bundle (CSB) lock once the CSB retrieval is complete. If the provided lock key matches the current value of the lock, the lock is released and the procedure returns success. If the lock key does not match the current value of the lock or if the lock is not active, the procedure returns an error. Documented return codes: ok, csbReleaseFailedNoLock, csbReleaseFailedInvalidKey.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_release_support_data(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (int) – The key returned by reserveSupportData. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_remove_async_mirror_group_member(system_id, body, **kwargs)[source]¶

This procedure will remove a member from an Async Mirror Group. Documented return codes: ok, arvmGroupDoesNotExist, arvmMirrorMemberDoesNotExist, remoteInternalError, arvmRemoteMirrorMemberDoesNotExist, remoteDatabaseError.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_remove_async_mirror_group_member(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (AsyncMirrorGroupRemoveMemberDescriptor) – An object containing all of the required attributes to remove an Asynchronous Mirror Group member. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_remove_bundle_keys(system_id, **kwargs)[source]¶

Removes all bundle keys that have been applied to change feature bundles. Documented return codes: ok, error, controllerInServiceMode.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_remove_bundle_keys(system_id, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_remove_drives_from_flash_cache(system_id, body, **kwargs)[source]¶

This procedure reconfigures the flash cache volume group to remove drives. Documented return codes: ok, error, illegalParam, noHeap, internalError, invalidDriveref, duplicateDrives, invalidDriveState, notFlashcacheVol, flashcacheDeleted, flashcacheFailed.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_remove_drives_from_flash_cache(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (FlashCacheReconfigureDrivesDescriptor) – The flash cache reference and list of drive references to be removed. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_remove_mirror(system_id, body, **kwargs)[source]¶

Deletes a mirror volume. Documented return codes: ok, illegalParam, volumeNotExist, internalError, iconFailure, invalidVolumeref, ghostVolume, invalidMirrorvol, onlyLocalMirrorDeleted, rvmSpmError.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_remove_mirror(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – A MirrorProxyRef object which identifies the Mirror Proxy Volume to be removed. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_remove_pit_consistency_group_member(system_id, body, **kwargs)[source]¶

This procedure will remove a member from a PiT consistency group. Documented return codes: ok, invalidPitGroupRef.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_remove_pit_consistency_group_member(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (PITConsistencyGroupRemoveMemberDescriptor) – Descriptor for the consistency group member to be removed. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_remove_snmp_community(system_id, body, **kwargs)[source]¶

This procedure is used to remove a previous configured SNMP community from the list of known community strings. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_remove_snmp_community(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (SNMPCommunityRefList) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_remove_snmp_trap_destination(system_id, body, **kwargs)[source]¶

This procedure is used to remove a previously configured SNMP trap destination. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_remove_snmp_trap_destination(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (SNMPTrapDestinationRefList) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_remove_volume_copy(system_id, body, **kwargs)[source]¶

Removes a volume copy. Documented return codes: ok, illegalParam, noHeap, internalError, invalidVolumeref, ghostVolume.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_remove_volume_copy(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – A VolumeCopyRef object that identifies the volume copy to be removed. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_rename_cluster(system_id, body, **kwargs)[source]¶

This procedure changes the user-assigned label for a Cluster object. Documented return codes: ok, partDupId, partLabelInvalid, partNodeNonexistent.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_rename_cluster(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (SYMbolRefWithUAL) – A SYMbolRefWithUAL object whose ref field identifies the cluster to be renamed, and whose label field provides the new user-assigned label for the cluster. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_rename_host(system_id, body, **kwargs)[source]¶

This procedure changes the user-assigned label for a Host object. Documented return codes: ok, partDupId, partLabelInvalid, partNodeNonexistent.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_rename_host(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (SYMbolRefWithUAL) – A SYMbolRefWithUAL object whose ref field identifies the host to be renamed, and whose label field provides the new user-assigned label for the host. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_rename_host_port(system_id, body, **kwargs)[source]¶

This procedure changes the user-assigned label for a HostPort object. Documented return codes: ok, partDupId, partNodeNonexistent.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_rename_host_port(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (HostPortRenameDescriptor) – A SYMbolRefWithUAL object whose ref field identifies the host port to be renamed, and whose label field provides the new user-assigned label for the host port. This procedure does not apply to iSCSI. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_replace_drive(system_id, body, **kwargs)[source]¶

This procedure causes a drive, A, that is not part of a volume group to replace a drive, B, that is part of a volume group. The end result is that the volume group drive composition is redefined to include A, and exclude B. The only candidate drives for being replaced are those that belong to a volume group and are either not-present or are failed. The only candidate drives for replacing a drive are those that are either unassigned or are a fully-integrated hot spare. Documented return codes: ok, driveTypeMismatch.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_replace_drive(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (DriveReplacementDescriptor) – A DriveReplacementDescriptor structure that identifies the drive to replace and the replacement drive. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_reprovision_drive(system_id, body, **kwargs)[source]¶

This procedure resets each drive’s lock key to a new, random value and disables each drive’s security system. Documented return codes: ok, illegalParam, notImplemented.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_reprovision_drive(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (DriveRefList) – A list of drive reference values, which identifies the drives to be re-provisioned. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_request_removal(system_id, body, **kwargs)[source]¶

This procedure turns the Ready to Remove indicator light on or off or puts the Ready to Remove indicator into automatic mode, for the component specified in the RTRUpdateDescriptor. Documented return codes: ok, error, illegalParam, downloadInProgress.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_request_removal(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (RTRUpdateDescription) – An RTRUpdateDescription object that indicates the component to modify and the control to execute. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_request_to_remove(system_id, body, **kwargs)[source]¶

This procedure turns the Ready to Remove indicator light on or off or puts the Ready to Remove indicator into automatic mode, for the component specified in the RTRUpdateDescriptor. This procedure is deprecated. The requestRemoval procedure should be used instead. Documented return codes: ok, error, illegalParam, downloadInProgress.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_request_to_remove(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (RTRUpdateDescriptor) – An RTRUpdateDescriptor object that indicates the component to modify and the control to execute. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_reserve_support_data(system_id, **kwargs)[source]¶

This procedure attempts to acquire the Customer Support Bundle lock. If the lock is successfully acquired the procedure returns success and the lock key. If another client owns the lock a failure indication is returned along with an integer indicating the suggested number of seconds to wait before retrying the reservation. Documented return codes: ok, csbReserveFailed.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_reserve_support_data(system_id, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	ReserveSupportDataReturned If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_reset_async_mirror_sync_statistics(system_id, body, **kwargs)[source]¶

This procedure will reset (clear) synchronization time statistics for a list of mirror members. Documented return codes: ok, notImplemented.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_reset_async_mirror_sync_statistics(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (AsyncMirrorSyncStatisticsResetDescriptor) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_reset_controller(system_id, body, **kwargs)[source]¶

This procedure requests a reboot of the given controller. Documented return codes: ok, error, illegalParam, noHeap, tryAlternate, invalidRequest, invalidControllerref, controllerInServiceMode.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_reset_controller(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – The value of the controller reference for the controller that is to be rebooted. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_reset_cumulative_statistics(system_id, **kwargs)[source]¶

This procedure sets all cumulative statistics on each controller back to zero and sets a new base time equal to the current time. Documented return codes: ok, error, invalidRequest.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_reset_cumulative_statistics(system_id, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_reset_discrete_time_series(system_id, body, **kwargs)[source]¶

This procedure resets the related discrete time series statistical streams on both controller, i.e., it sets the number of observations for the series back to zero. Documented return codes: ok, error, illegalParam, invalidRequest.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_reset_discrete_time_series(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (int) – A StatStreamId object that identifies the discrete time series to reset. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_reset_histogram(system_id, body, **kwargs)[source]¶

This procedure resets the related histograms both controllers, i.e., it sets the number of entries in each category and all observation tallies back to zero. Documented return codes: ok, error, illegalParam, invalidRequest.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_reset_histogram(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (int) – A StatStreamId object that identifies the histograms to reset. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_reset_mel(system_id, **kwargs)[source]¶

This procedure clears all entries from the Major Events Log. Documented return codes: ok, tryAlternate.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_reset_mel(system_id, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_reset_sa_configuration(system_id, body, **kwargs)[source]¶

This procedure provides a way to clear the storage array configuration without bringing it all the way back to its initial state. Core security and identification may be retained, if desired. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_reset_sa_configuration(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – A ResetConfigType object that indicates which parts of the array configuration are to be cleared. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_restart_pit_consistency_group_view(system_id, body, **kwargs)[source]¶

This procedure will restart a Consistency Group View (restart all of its associated member Views). Documented return codes: ok, invalidPitForView.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_restart_pit_consistency_group_view(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (PITConsistencyGroupViewRestartDescriptor) – An object containing all of the attributes required to restart a Consistency Group View. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_restart_pit_view(system_id, body, **kwargs)[source]¶

This procedure will restart a PiT View. Documented return codes: ok, invalidPitForView.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_restart_pit_view(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (PITViewRestartDescriptor) – An object containing all of the attributes required to restart a PiT View. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_resume_async_mirror_group(system_id, body, **kwargs)[source]¶

Resume an Async Mirror Group. Documented return codes: ok, arvmGroupDoesNotExist, arvmRecoveryPointDeletionRequired, arvmGroupNotPrimary, arvmGroupNotSuspended, arvmResumeFailure, arvmGroupHasIncompleteMember, remoteInternalError, arvmRemoteGroupDoesNotExist, remoteDatabaseError, arvmRemoteResumeFailure.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_resume_async_mirror_group(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (AsyncMirrorGroupResumeDescriptor) – A descriptor containing a reference to the Asynchronous Mirror Group to resume. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	AsyncMirrorGroupActionResult If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_resume_consistency_group(system_id, body, **kwargs)[source]¶

This procedure resumes the communication for all mirrors in a Write Consistency group with a specified group number. Documented return codes: ok, noHeap, internalError, iconFailure, legacyRvmAsyncModeUnsupported.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_resume_consistency_group(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – This object contains information about the write consistency group object. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_resume_flash_cache(system_id, body, **kwargs)[source]¶

This procedure resumes a previously suspended flash cache. Documented return codes: ok, error, illegalParam, noHeap, volumeNotExist, internalError, invalidVolumeref, flashcacheNotSuspended, notFlashcacheVol, flashcacheDeleted, flashcacheFailed, flashcacheDegradedState.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_resume_flash_cache(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – A reference to the flash cache object. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_resume_mirror(system_id, body, **kwargs)[source]¶

This procedure resumes the communication between a mirror pair. Documented return codes: ok, illegalParam, noHeap, tryAlternate, internalError, iconFailure, invalidVolumeref, ghostVolume, invalidMirrorvol, rvmVersionMismatch, rvmOperNotAllowedOnSec.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_resume_mirror(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – This object contains information identifying the Mirror Proxy Volume to be removed. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_resume_mirror_list(system_id, body, **kwargs)[source]¶

This procedure resumes the communication between all mirrored pairs specified in the MirrorVolumeList. Documented return codes: ok, noHeap, internalError, iconFailure.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_resume_mirror_list(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (MirrorVolumeList) – This object contains information identifying the list of mirrored pairs on which to perform the resume operation. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_resume_pit_rollback(system_id, body, **kwargs)[source]¶

This procedure will resume a paused rollback on the specified PiT. Documented return codes: ok, repositoryOffline, invalidPitRef, pitGroupsFeatureDisabled.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_resume_pit_rollback(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – A reference to the PiT rollback to be resumed. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_resume_snapshot_rollback(system_id, body, **kwargs)[source]¶

This procedure is used to resume suspended snapshot rollback operations. Documented return codes: ok, rollbackStartFailure.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_resume_snapshot_rollback(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – A reference to the snapshot for which to resume the snapshot rollback operation. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_revive_pit_group(system_id, body, **kwargs)[source]¶

This procedure revives a failed PiT Group. Documented return codes: ok, repositoryOffline, rollbackInProgress.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_revive_pit_group(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – A reference to the PiT Group you want to revive. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_revive_pit_view(system_id, body, **kwargs)[source]¶

This procedure revives a failed PiT View. Documented return codes: ok, repositoryOffline.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_revive_pit_view(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – A reference to the PiT View you want to revive. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_role_change(system_id, body, **kwargs)[source]¶

This procedure changes the role of the mirror volume. Documented return codes: ok, illegalParam, noHeap, internalError, invalidVolumeref, ghostVolume, invalidMirrorvol, localRoleChangeFailed, remoteRoleChangeFailed, localRoleChangeSuccessful, localRoleChangedNotForced, remoteRoleChangedLocalFailed, rvmVersionMismatch, rvmRemoteArrayError, rvmCommunicationError, secNotPromoteable, priNotDemoteable.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_role_change(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (MirrorRoleChangeDescriptor) – The MirrorRoleChangeDescriptor object. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

netapp.santricity.api.symbol.s_api module¶

SApi.py

class netapp.santricity.api.symbol.s_api.SApi(api_client=None)[source]¶

Bases: object

symbol_scan_volume(system_id, body, **kwargs)[source]¶

This procedure causes a scan of the specified volume over the specified extent. The scan stops on any media or parity error encountered and reports the error. The procedure can also be used to repair media errors and parity errors. Documented return codes: ok, illegalParam, noHeap, tryAlternate, invalidVolumeref, volumeOffline, volumeNotOptimal, parityScanFailed, parityRepairFailed, mediaRepairFailed.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_scan_volume(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (VolumeScanDescriptor) – A VolumeScanDescriptor that specifies the volume and extent to be scanned and contains indicators to enable repairing of media and parity errors. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	ParityScanResponse If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_secure_disk_pool(system_id, body, **kwargs)[source]¶

This procedure converts the specified disk pool to a secure volume group. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_secure_disk_pool(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – An object containing all of the required attributes to convert the specified disk pool to a secure volume group. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_secure_volume_group(system_id, body, **kwargs)[source]¶

This procedure converts the specified volume group to a secure volume group. Documented return codes: ok, notImplemented, invalidVolumegroupref, volsInVgUsingNonSecureCapableFlashcache, volsInVgUsingSecureDisabledFlashcache.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_secure_volume_group(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – The VolumeGroupRef identifier for the volume to be secured. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_send_drive_firmware(system_id, body, **kwargs)[source]¶

This procedure sends chunks to the parallel drive firmware download process. Documented return codes: ok, error, illegalParam, noHeap, invalidRequest, invalidOffset, overrun, invalidChunksize, invalidSetid, validationError, controllerInServiceMode.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_send_drive_firmware(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (DriveFirmwareChunkDescriptor) – This object contains information about the DriveFirmwareChunkDescriptor. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_set_alarm(system_id, body, **kwargs)[source]¶

This procedure sets the allowed alarm controls. Documented return codes: ok, error, illegalParam.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_set_alarm(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (AlarmUpdateDescriptor) – An AlarmUpdateDescriptor object that indicates the alarm to modify and the alarm control to activate. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_set_asup_status(system_id, body, **kwargs)[source]¶

This procedure is used to set the current Autosupport status values. Documented return codes: ok, notImplemented.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_set_asup_status(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (AsupStatus) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_set_async_mirror_group_params(system_id, body, **kwargs)[source]¶

This procedure will change the parameters of an Async Mirror Group. Documented return codes: ok, invalidWarnThreshold, arvmGroupUserLabelExists, arvmGroupHasIncompleteMember, invalidSyncPriority, invalidRecoveryPointAlertThreshold, invalidSyncAlertThreshold, arvmOrphanGroup, arvmOrphanMember, arvmInvalidSyncInterval, remoteInternalError, arvmRemoteGroupUserLabelExists, arvmRemoteGroupDoesNotExist, remoteDatabaseError.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_set_async_mirror_group_params(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (AsyncMirrorGroupParamsUpdateDescriptor) – An object containing the Asynchronous Mirror Group parameters. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_set_auto_load_balancing(system_id, body, **kwargs)[source]¶

This procedure enables or disables the auto load balancing capability on this array. Documented return codes: ok, noHeap, databaseError.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_set_auto_load_balancing(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (AutoLoadBalancingControlDescriptor) – Input descriptor indicating whether auto load balancing is to be enabled or disabled (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_set_auto_resync(system_id, body, **kwargs)[source]¶

This procedure sets the allowable options for the auto resynchronization. Documented return codes: ok, illegalParam, noHeap, internalError, iconFailure, invalidVolumeref, ghostVolume, invalidMirrorvol, rvmVersionMismatch, rvmOperNotAllowedOnSec.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_set_auto_resync(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (MirrorAutoResyncDescriptor) – This object determines whether auto resynchronization is allowed. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_set_battery_params(system_id, body, **kwargs)[source]¶

This procedure sets the battery parameters for the given battery. Documented return codes: ok, illegalParam, noHeap, volumeNotExist, tryAlternate, internalError, noVolumes.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_set_battery_params(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (BatteryParamsUpdateDescriptor) – A descriptor object that specifies the battery properties. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_set_cluster_performance_limitation_values(system_id, body, **kwargs)[source]¶

This procedure allows the user to limit the performance of a host cluster. The limitations that can be set are throughput (MB/s) and IOPs. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_set_cluster_performance_limitation_values(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (ClusterPerformanceLimitationValuesDescriptor) – The procedure takes as input a structure containing the limitations on the performance of the cluster. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_set_controller_nvsram(system_id, body, **kwargs)[source]¶

This procedure is used to modify a portion of the controller’s NVSRAM. Note that the NVSRAM data is changed only on the controller to which this request is directed. Documented return codes: ok, error, illegalParam, noHeap, nvramError, invalidRegionid.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_set_controller_nvsram(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (NVSRAMUpdateDescriptor) – An NVSRAMUpdateDescriptor object that specifies the region to be modified, the starting byte offset within the region, and the size and value of the new data to be stored into NVSRAM. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_set_controller_service_mode(system_id, body, **kwargs)[source]¶

This procedure places a controller in Service Mode. It replaces the obsolete setControllerToPassive procedure. The command is serviced by the controller opposite to controllerRef. Documented return codes: ok, illegalParam, noHeap, tryAlternate, modesenseError.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_set_controller_service_mode(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – The value of the controller reference for the controller to be placed in service mode. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_set_controller_time(system_id, body, **kwargs)[source]¶

This procedure allows the client to set the clock of the controller to the specified value. Note that the clock value is only set on the controller to which this request is directed. If the client wishes to set the clock value on each controller, then an independent request of this form should be directed to each controller. Documented return codes: ok, illegalParam.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_set_controller_time(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (int) – A 64-bit integer value that represents the new clock value to be set on the controller. The integer specifies the time value as the number of seconds that have elapsed since 12:00AM GMT on January 1, 1970. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_set_controller_to_active(system_id, body, **kwargs)[source]¶

This procedure causes the specified controller to be transitioned into the active state. If the controller was previously active, no visible changes will occur as a result of this operation. If it was previously passive or in service mode, it will be made active. After this transition occurs, it will be possible to assign ownership of volume groups to the controller so that it may participate in standard I/O operations. Documented return codes: ok, error, illegalParam, noHeap, internalError, invalidRequest, iconFailure, cacheSyncFailure, invalidControllerref, modesenseError.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_set_controller_to_active(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – The value of the controller reference for the controller that is to be made active. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_set_controller_to_failed(system_id, body, **kwargs)[source]¶

This procedure marks the specified controller as being failed. Furthermore, the alternate of the specified controller will force the failed controller into a reset state (if possible). Documented return codes: ok, error, illegalParam, noHeap, tryAlternate, internalError, invalidRequest, iconFailure, cacheSyncFailure, invalidControllerref, modesenseError, controllerInServiceMode.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_set_controller_to_failed(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – The value of the controller reference for the controller that is to be marked failed. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_set_controller_to_optimal(system_id, body, **kwargs)[source]¶

This procedure causes the specified controller’s state to be set to optimal. If the controller was previously in the failed state, it will be reactivated. If necessary, the alternate controller will also remove any forced reset signal being applied to the specified controller. Documented return codes: ok, error, illegalParam, noHeap, internalError, invalidRequest, iconFailure, cacheSyncFailure, invalidControllerref, modesenseError.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_set_controller_to_optimal(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – The value of the controller reference for the controller to be set to the optimal state. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_set_controller_to_passive(system_id, body, **kwargs)[source]¶

This procedure causes the specified controller to be transitioned to the passive state. All volume groups owned by the controller will be transitioned to the alternate controller, which remains in the active state. Documented return codes: obsolete.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_set_controller_to_passive(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – The value of the controller reference for the controller that is to be made passive. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_set_disk_pool_priority(system_id, body, **kwargs)[source]¶

This procedure will set the Disk Pool Reconstruction and Background Operation priorities. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_set_disk_pool_priority(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (DiskPoolPriorityUpdateDescriptor) – An object containing all of the attributes required to set priorities for a Disk Pool. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_set_disk_pool_reserved_drive_count(system_id, body, **kwargs)[source]¶

This procedure will set the Disk Pool Reserved Drive Count value. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_set_disk_pool_reserved_drive_count(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (DiskPoolReservedDriveCountUpdateDescriptor) – An object containing all of the attributes required to set a reserved drive count value on a disk pool. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_set_disk_pool_threshold(system_id, body, **kwargs)[source]¶

This procedure will set the Disk Pool Utilization Threshold values. Documented return codes: ok, invalidCriticalThreshold.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_set_disk_pool_threshold(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (DiskPoolThresholdUpdateDescriptor) – An object containing all of the attributes required to set utilization threshold values for a Disk Pool. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_set_disk_pool_to_complete(system_id, body, **kwargs)[source]¶

This procedure forces the Disk Pool to a complete (optimal) state. This may be necessary if a drive is missing and the drive is not going to be replaced. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_set_disk_pool_to_complete(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – A reference to the Disk Pool to complete. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_set_disk_pool_user_label(system_id, body, **kwargs)[source]¶

This procedure is used to set the user assigned label for the disk pool. Documented return codes: ok, illegalParam.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_set_disk_pool_user_label(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (VolumeGroupLabelUpdateDescriptor) – A DiskPoolLabelUpdateDescriptor structure that contains the user label and a reference to the volume group to update. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_set_drive_channel_state(system_id, body, **kwargs)[source]¶

This procedure sets the drive channel state to either degraded or optimal. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_set_drive_channel_state(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (DriveChannelStateDescriptor) – This object contains information on how to request a drive channel state change from the array. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_set_drive_physical_security_id(system_id, body, **kwargs)[source]¶

This procedure is used to set the Physical Security ID for a drive. The PSID is required in order to set a FIPS drive back to factory settings if the previous PSID is lost. In that case, the drive must be set back to factory settings in order to be used. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_set_drive_physical_security_id(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (DrivePhysicalSecurityIdDescriptor) – The input structure contains a reference to the drive and the Physical Security ID string. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_set_drive_temperature_polling_interval(system_id, body, **kwargs)[source]¶

This procedure set the interval in minutes between automatic polls of drive temperatures. For interval > 0, automatic polling is enabled at the specified interval. For interval == 0, automatic polling is disabled. Each polling event will update the driveTemperature field in each Drive structure in the ObjectBundle. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_set_drive_temperature_polling_interval(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (int) – Polling interval in minutes. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_set_drive_to_failed(system_id, body, **kwargs)[source]¶

This procedure marks the specified drive as being failed. In general, this will also impact the operational state of the volume group to which the drive is assigned, plus all volumes defined on that volume group. The precise impact on the states of these other objects may vary, as it depends on the RAID level of the volumes, as well as the states of the other drives in the volume group. Documented return codes: ok, error, illegalParam, noHeap, driveNotExist, tryAlternate, invalidDriveref, databaseError, invalidDriveState, takeRecoveryActionsFirst.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_set_drive_to_failed(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – The value of the drive reference for the drive that is to be marked failed. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_set_drive_to_optimal(system_id, body, **kwargs)[source]¶

This procedure forces the specified drive to the optimal state, including clearing the PFA condition for the drive, if any. Returning the drive to optimal may cause volumes on the associated volume group to be returned to the optimal state as well. This is a potentially dangerous operation, since a failed drive is usually accompanied by some form of parity inconsistency. Forcing a drive from the failed state to the optimal state may disrupt the controller’s normal methods of providing availability in a degraded state, and may thus result in corrupted data being returned on ensuing data transfers to the host system. Documented return codes: ok, illegalParam, noHeap, tryAlternate, background, invalidDriveref, invalidDriveState.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_set_drive_to_optimal(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – The value of the drive reference for the drive to be returned to the optimal state. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_set_flash_cache_params(system_id, body, **kwargs)[source]¶

This procedure sets the parameters on a given flash cache. Documented return codes: ok, illegalParam, noHeap, internalError, flashcacheInvalidConfigType, notFlashcacheVol, flashcacheDeleted, flashcacheFailed, flashcacheDegradedState.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_set_flash_cache_params(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (FlashCacheParamsUpdateDescriptor) – A flash cache reference, configuration type, and whether or not flash cache should be enabled on new volumes. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_set_function_state(system_id, body, **kwargs)[source]¶

This procedure is used to get the state of a function, enable or disable the function, or revert the function back to its default value. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_set_function_state(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (FunctionStateDescriptor) – The function ID and the action to be performed. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	FunctionStateReturned If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_set_high_resolution_sampling(system_id, body, **kwargs)[source]¶

This procedure enables or disables high resolution statistics gathering. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_set_high_resolution_sampling(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (HighResolutionRequestDescriptor) – None. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	HighResolutionReturned If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_set_host_interface_params(system_id, body, **kwargs)[source]¶

This procedure updates the I/O interface parameters for the controller to which the request is directed. Documented return codes: ok, error, noHeap, tryAlternate, nvramError, invalidControllerref, invalidFibreid.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_set_host_interface_params(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (InterfaceUpdateDescriptor) – An InterfaceUpdateDescriptor object that provides new values for the host I/O interface parameters. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_set_host_port_properties(system_id, body, **kwargs)[source]¶

This procedure sets selected HostPort properties, as specified by the input argument. It is a replacement for the deprecated moveHostPort, renameHostPort. Documented return codes: ok, requestFailedDueToPiRestrictions.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_set_host_port_properties(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (HostPortPropertiesUpdateDescriptor) – A HostPortPropertiesUpdateDescriptor structure which indicates the affected host port, which properties to set, and what values to set for them. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_set_host_port_type(system_id, body, **kwargs)[source]¶

Changes the “host port type” attribute of a given HostPort object. Changing an individual host port type will cause all host port types to be changed if SPM is not enabled. This procedure does not apply to iSCSI; for iSCSI, the host type is set at the host level. Documented return codes: ok, illegalParam, partNodeNonexistent.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_set_host_port_type(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (HostPortTypeUpdateDescriptor) – A HostPortTypeUpdateDescriptor object that identifies the HostPort to be modified, and also provides the new type index value that specifies the type of the host port. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_set_host_properties(system_id, body, **kwargs)[source]¶

This procedure sets selected host properties as indicated by the input argument. It is a replacement for the deprecated moveHost, renameHost. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_set_host_properties(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (HostPropertiesUpdateDescriptor) – A HostPropertiesUpdateDescriptor, indicating the affected Host, which properties to set, and what values to set them to. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_set_host_specific_nvsram(system_id, body, **kwargs)[source]¶

This procedure updates the NVSRAM for the Host Specific region. Documented return codes: ok, error, illegalParam, noHeap, nvramError, invalidRegionid, invalidHostTypeIndex.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_set_host_specific_nvsram(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (HostSpecificNVSRAMUpdateDescriptor) – A HostSpecificNVSRAMUpdateDescriptor object that specifies the region ID (in this case 0xF2), the host index for a specific host, the starting offset within the region, the number of bytes, and the values to be written. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_set_ib_statistics_baseline(system_id, **kwargs)[source]¶

This procedure, from the client’s perspective, resets the InfiniBand baselined statistical counters to zero. It is a logical reset in the sense that the raw counts maintained in hardware and firmware are not actually reset; instead the firmware makes a snapshot of the current counter values and uses that to report deltas in counts when the statistics are fetched. The new baseline time is applied to both controllers, so that their counts are in sync with one another. If one controller resets without the other resetting, the counters become effectively out of sync and the client is made aware of this fact by the timestamp data reported along with the statistics. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_set_ib_statistics_baseline(system_id, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_set_initiator_properties(system_id, body, **kwargs)[source]¶

This procedure sets selected Initiator properties as indicated by the input argument. Documented return codes: ok, invalidAuthMethod, invalidSecret, secretAlreadyInUse, requestFailedDueToPiRestrictions.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_set_initiator_properties(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (InitiatorPropertiesUpdateDescriptor) – An InitiatorPropertiesUpdateDescriptor, indicating which Initiator properties to set and what values to set them to. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_set_iscsi_entity_properties(system_id, body, **kwargs)[source]¶

This procedure sets selected iSCSI entity properties for the storage array as indicated by the input argument. Documented return codes: ok, isnsDhcpNotSupported.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_set_iscsi_entity_properties(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (IscsiEntityPropertiesUpdateDescriptor) – An IscsiEntityPropertiesUpdateDescriptor, indicating which iSCSI entity properties to set and what values to set them to. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_set_iscsi_interface_properties(system_id, body, **kwargs)[source]¶

This procedure sets selected properties of a controller iSCSI interface, as indicated by the input argument. Documented return codes: ok, invalidInterfaceref, duplicateIscsiIpAddress, portSpeedConflict.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_set_iscsi_interface_properties(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (IscsiInterfacePropertiesUpdateDescriptor) – An IscsiInterfacePropertiesUpdateDescriptor, indicating the affected iSCSI interface, which properties to set, and what values to set them to. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_set_iscsi_statistics_baseline(system_id, **kwargs)[source]¶

This procedure, from the client’s perspective, resets the iSCSI statistical counters to zero. It is a logical reset in the sense that the raw counts maintained in hardware and firmware are not actually reset; instead the firmware makes a snapshot of the current counter values and uses that to report deltas in counts when the statistics are fetched. The new baseline time is applied to both controllers, so that their counts are in sync with one another. If one controller resets without the other resetting, the counters become effectively out of sync and the client is made aware of this fact by the timestamp data reported along with the statistics. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_set_iscsi_statistics_baseline(system_id, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_set_key_value_tag_mapping(system_id, body, **kwargs)[source]¶

This procedure persists the association between the Key-Value tags and the Volumes (or Workloads). This procedure is used both for creating the initial mappings and to update. Each execution will remove any existing mappings and replace them with the mappings defined within the argument list. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_set_key_value_tag_mapping(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (KeyValueTagMappingSetDescriptorList) – The input is a list of mappings, each mapping consists of a Volume Reference and a Key-Value Pair reference. This method will create the initial associations and can be used to perform a replacement of those associations. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_set_lock_key(system_id, **kwargs)[source]¶

This procedure is used in conjunction with the createLockKey procedure. This request may be issued to change the existing array lock key or to set an array lock key after a database adoption. The procedure commits the lock key generated by the createLockKey procedure to the drives and to the controllers. Documented return codes: ok, volumeNotOptimal, driveSecurityEnabledFailed, lockkeyFailed, noFdeDrives, keyDoesNotExist.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_set_lock_key(system_id, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_set_network_parameters(system_id, body, **kwargs)[source]¶

This procedure updates the network parameters. Documented return codes: ok, illegalParam, noHeap, tryAlternate, background.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_set_network_parameters(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (EthernetParamsUpdateDescriptor) – An EthernetParamsUpdateDescriptor object that specifies the controller IP address, the gateway IP address, the network subnet mask, and bootp enable/disable. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_set_pit_consistency_group_params(system_id, body, **kwargs)[source]¶

This procedure will modify the attributes of a PiT consistency group. Documented return codes: ok, invalidRollbackPriority, invalidWarnThreshold, invalidPitConsistencyGroupLabel, invalidPitAutoDeleteLimit, invalidPitRepositoryFullPolicy, attributeFixedByArvm, pitGroupsFeatureDisabled.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_set_pit_consistency_group_params(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (PITConsistencyGroupParamsUpdateDescriptor) – Descriptor for the consistency group parameters to be updated. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_set_pit_consistency_group_view_params(system_id, body, **kwargs)[source]¶

This procedure changes the user-settable parameters on a PITConsistencyGroupView. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_set_pit_consistency_group_view_params(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (PITConsistencyGroupViewParamsUpdateDescriptor) – An object containing the required user-settable attributes to set on a PiT Consistency Group View. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_set_pit_group_params(system_id, body, **kwargs)[source]¶

This procedure will update the changeable parameters of a PiT Group. Documented return codes: ok, invalidBasevol, invalidRollbackPriority, invalidWarnThreshold, baseVolumeFailed, invalidPitGroupLabel, invalidPitAutoDeleteLimit, invalidPitRepositoryFullPolicy, invalidPitGroupRef, pitGroupInConsistencyGroup, attributeFixedByArvm, pitGroupsFeatureDisabled.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_set_pit_group_params(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (PITGroupParamsUpdateDescriptor) – Structure containing PiT parameter data. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_set_pit_view_params(system_id, body, **kwargs)[source]¶

This procedure will change the attributes of an existing PiT View. Documented return codes: ok, invalidWarnThreshold, pitViewInConsistencyGroup, pitGroupsFeatureDisabled.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_set_pit_view_params(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (PITViewParamsUpdateDescriptor) – Descriptor for the PiT View parameters to be updated. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_set_remote_target_properties(system_id, body, **kwargs)[source]¶

This procedure sets the selected remote target properties as indicated by the input arguments. Documented return codes: ok, invalidAuthMethod, invalidSecret, secretAlreadyInUse.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_set_remote_target_properties(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (InitiatorTargetPropertiesUpdateDescriptor) – The updated settings for the new target initiator identified in the descriptor. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_set_rlogin_capability(system_id, body, **kwargs)[source]¶

This procedure allows rlogin to the controller to be enabled or disabled. Documented return codes: ok, illegalParam, noHeap, tryAlternate, background.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_set_rlogin_capability(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (RloginUpdateDescriptor) – The RloginUpdateDescriptor object is used for specifying the remote login capability of the controller (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_set_rls_baseline(system_id, **kwargs)[source]¶

This procedure sets the RLS baseline for all devices. The baseline is used to indicate the difference in error counts from when the baseline was established and the time at which the RLS data is requested. Documented return codes: ok, dstNotFibre.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_set_rls_baseline(system_id, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_set_sa_cache_params(system_id, body, **kwargs)[source]¶

This procedure updates the cache parameters that are maintained on a per-array basis, across all controllers in the array. Documented return codes: ok, illegalParam, noHeap, volumeNotExist, volumeReconfiguring, tryAlternate, internalError, invalidCacheblksize, invalidFlushThreshold, invalidFlushAmount, noVolumes, controllerInServiceMode.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_set_sa_cache_params(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (SACacheParamsUpdateDescriptor) – An SACacheParamsUpdateDescriptor object that provides new values for the storage array cache management parameters. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_set_sa_media_scan_period(system_id, body, **kwargs)[source]¶

This procedure sets the target media scan period for background media scans to the value specified by the caller. The period is specified in units of days, and governs the approximate time required for a complete media scan of all volumes and drives in the system. The allowed period values can be determined by checking the appropriate fields of the FeatureParameters object for the storage array. Documented return codes: ok, error, illegalParam, tryAlternate, invalidScanperiod, controllerInServiceMode.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_set_sa_media_scan_period(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (int) – The desired media scan period, expressed in units of days. This value must be within the valid range of media scan periods supported the controller. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_set_sa_tray_positions(system_id, body, **kwargs)[source]¶

This procedure is used by the client to request that the controller store (in nonvolatile storage) a TrayPositionList object that provides information about the relative physical positions of the storage array’s trays within their enclosing rack(s) or container(s). Documented return codes: ok, error, illegalParam, noHeap, invalidTrayposLength.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_set_sa_tray_positions(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (TrayPositionList) – The TrayPositionList object to be stored for future retrieval. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_set_sa_user_label(system_id, body, **kwargs)[source]¶

This procedure is used by a client to modify the user-assigned label for the storage array. The label value is stored in non-volatile storage and returned to the client as part of the SAInfo object. Documented return codes: ok, error, illegalParam, invalidLabel.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_set_sa_user_label(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – The new user-assigned label for the storage array. This value is presented to the controller as a variable-length opaque byte array. However, the intention is that the byte array will contain a string value in double-byte character set format, with each two bytes representing one character value. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_set_sa_view_password(system_id, body, **kwargs)[source]¶

This procedure is used to set the initial view array password or change an existing view array password. Documented return codes: ok, authFailPassword, adminPasswordNotSet.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_set_sa_view_password(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (EncryptedPassword) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_set_simplex_mode(system_id, body, **kwargs)[source]¶

This procedure is used to enable and disable Simplex mode. Documented return codes: ok, illegalParam, noHeap, tryAlternate, notImplemented, internalError, iconFailure, mirrorsPresent.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_set_simplex_mode(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – An enumeration object that describes the controller’s redundancy mode. Use CTRL_REDUNDANCY_MODE_DUPLEX to set the redundancy mode to duplex and CTRL_REDUNDANCY_MODE_SIMPLEX to set the redundancy mode to simplex. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_set_snapshot_params(system_id, body, **kwargs)[source]¶

This procedure is used to set various snapshot parameters including the repository warning threshold, the repository full policy, and the rollback operation priority. Documented return codes: ok, illegalParam, noHeap, tryAlternate, internalError, invalidVolumeref, snapNotAvailable, ghostVolume, invalidRollbackPriority, invalidWarnThreshold.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_set_snapshot_params(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (SnapshotParamsUpdateDescriptor) – A SnapshotParamsUpdateDescriptor object that specifies the various snapshot parameters. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_set_snmp_community_params(system_id, body, **kwargs)[source]¶

This procedure is used to modify an existing SNMP community. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_set_snmp_community_params(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (SNMPCommunityParamsUpdateDescriptorList) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_set_snmp_system_variables(system_id, body, **kwargs)[source]¶

This procedure is used to set values of user-settable SNMP system variables. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_set_snmp_system_variables(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (SNMPSystemVariablesUpdateDescriptor) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_set_snmp_trap_destination_params(system_id, body, **kwargs)[source]¶

This procedure is used to modify an existing SNMP trap destination. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_set_snmp_trap_destination_params(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (SNMPTrapDestinationParamsUpdateDescriptorList) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_set_storage_array_properties(system_id, body, **kwargs)[source]¶

This procedure sets selected properties for the storage array that is the recipient of the call. Documented return codes: ok, illegalParam.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_set_storage_array_properties(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (StorageArrayPropertiesUpdateDescriptor) – A StorageArrayPropertiesUpdateDescriptor, indicating which properties to set and what values to set them to. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_set_target_properties(system_id, body, **kwargs)[source]¶

This procedure sets selected Target properties as indicated by the input argument. Documented return codes: ok, invalidAuthMethod, invalidSecret, secretAlreadyInUse.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_set_target_properties(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (TargetPropertiesUpdateDescriptor) – A TargetPropertiesUpdateDescriptor, indicating the affected Target, which properties to set and what values to set them to. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_set_thin_volume_capacity_threshold(system_id, body, **kwargs)[source]¶

This procedure will set a thin volume’s capacity threshold warning level. Documented return codes: ok, internalError, invalidVolumeref, invalidWarnThreshold, illegalVolume, thresholdBelowUsedCapacity, thinVolumeParametersCannotBeModified.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_set_thin_volume_capacity_threshold(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (ThinVolumeThresholdUpdateDescriptor) – An object containing all of the required attributes for setting the capacity threshold warning level on a thin volume. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_set_thin_volume_expansion_policy(system_id, body, **kwargs)[source]¶

This procedure will set a thin volume’s repository volume expansion policy. Documented return codes: ok, internalError, invalidVolumeref, illegalVolume, invalidExpansionPolicy, thinVolumeParametersCannotBeModified.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_set_thin_volume_expansion_policy(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (ThinVolumeExpansionPolicyUpdateDescriptor) – An object containing all of the required attributes needed to set the repository volume expansion policy for a thin volume. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_set_thin_volume_provisioned_capacity_quota(system_id, body, **kwargs)[source]¶

This procedure will set a thin volume’s provisioned capacity quota. This is the maximum value to which a thin volume’s repository can grow. Documented return codes: ok, tryAlternate, internalError, invalidVolumeref, illegalVolume, invalidProvisionedCapacityQuota, invalidExpansionPolicy, invalidExpansionOperation, thinVolumeParametersCannotBeModified.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_set_thin_volume_provisioned_capacity_quota(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (ThinVolumeCapacityQuotaUpdateDescriptor) – An object containing all of the required attributes needed to set a thin volume’s provisioned capacity quota. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_set_thin_volume_reporting_policy(system_id, body, **kwargs)[source]¶

This procedure changes the reporting policy of a thin volume. The reporting policy controls how a thin volume is reported to the host on the SCSI interface, i.e., as a thin volume that supports unmap commands or as a thick volume. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_set_thin_volume_reporting_policy(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (ThinVolumeReportingPolicyUpdateDescriptor) – A ThinVolumeReportingPolicyUpdateDescriptor structure containing the arguments for the procedure call. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_set_tray_attributes(system_id, body, **kwargs)[source]¶

This procedure sets arbitrary “attribute data” for a specified tray enclosure. Only the attributes specified in the argument are affected by this operation. The old data in an affected attribute is completely overwritten by the new attribute data. Documented return codes: ok, error, illegalParam, noHeap, invalidRequest, invalidRequestForEnclosure.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_set_tray_attributes(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (TrayAttributeUpdateDescriptor) – A TrayAttributeUpdateDescriptor indicating which tray is to receive the attribute data, along with a list of elements defining new attribute data to be written. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_set_vol_xfer_alert_delay_period(system_id, body, **kwargs)[source]¶

This procedure is used to set the delay period before a volume transfer alert is issued. Documented return codes: ok, error, illegalParam.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_set_vol_xfer_alert_delay_period(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (int) – The delay period in seconds from 0 to 3600. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_set_volume_cache_params(system_id, body, **kwargs)[source]¶

This procedure updates the caching parameters for a particular volume as specified in the argument structure. Documented return codes: ok, error, illegalParam, noHeap, volumeNotExist, volumeReconfiguring, tryAlternate, internalError, invalidRequest, volumeFormatting, invalidVolumeref, volumeOffline, invalidCacheModifier, invalidReadahead, ghostVolume, cacheParametersNotChangeable.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_set_volume_cache_params(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (VolumeCacheParamsUpdateDescriptor) – A VolumeCacheParamsUpdateDescriptor object that specifies the volume whose cache parameters are to be updated, as well as the new parameter values themselves. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_set_volume_copy_params(system_id, body, **kwargs)[source]¶

This procedure modifies the parameters of a volume copy. Documented return codes: ok, illegalParam, noHeap, volumeNotExist, internalError, invalidCopyPriority, invalidVolumecopyref, copyChangeFailed, copyGhostTarget, copyTargetReservation.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_set_volume_copy_params(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (VolumeCopyParamsUpdateDescriptor) – A VolumeCopyParamsUpdateDescriptor object that identifies the copy request and a set of attributes to be used to update the existing attributes. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_set_volume_group_to_offline(system_id, body, **kwargs)[source]¶

This procedure marks a volume group offline. When this operation completes, all volumes in the volume group will be inaccessible for I/O operations. The drives that comprise the volume group can be removed from the storage array and, if desired, inserted into a different storage array. Documented return codes: ok, error, illegalParam, noHeap, driveNotUnassigned, volumeReconfiguring, tryAlternate, invalidRequest, invalidVolumeref, driveNotOptimal, driveRemoved, duplicateDrives, numdrivesAdditional, numdrivesGroup.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_set_volume_group_to_offline(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – The value of the volume group reference for the volume group to be placed offline. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_set_volume_group_to_online(system_id, body, **kwargs)[source]¶

This procedure marks a volume group online. It is typically used when the drives assigned to a volume group have been transported from one storage array to another. After the last such drive has been inserted into the new storage array, it is necessary to manually mark the volume group online. When this operation completes, assuming the drives are all functioning properly, the volumes defined in the volume group will become accessible for I/O operations. Documented return codes: ok, error, illegalParam, noHeap, driveNotUnassigned, volumeReconfiguring, tryAlternate, invalidRequest, invalidVolumeref, driveNotOptimal, duplicateDrives, numdrivesAdditional, numdrivesGroup.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_set_volume_group_to_online(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – The value of the volume group reference for the volume group to be placed online. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_set_volume_group_user_label(system_id, body, **kwargs)[source]¶

Sets the user assigned label for the volume group specified in the VolumeGroupLabelUpdate structure. Documented return codes: ok, illegalParam.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_set_volume_group_user_label(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (VolumeGroupLabelUpdateDescriptor) – A VolumeGroupUserLabelUpdateDescriptor structure that contains the user label and a reference to the volume group to update. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_set_volume_list_online(system_id, body, **kwargs)[source]¶

Places the set of volumes online. Documented return codes: ok, noHeap, volumeNotExist, internalError, invalidVolumeref, volumeNotOptimal.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_set_volume_list_online(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (AbstractVolRefList) – The list AbstractVolRefList of volumes to be placed online. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	VolumeListReturned If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_set_volume_media_scan_params(system_id, body, **kwargs)[source]¶

This procedure sets the media scan parameters for a particular volume. Each volume can be configured to either participate in media scans or not. Furthermore, if a volume is configured to participate, it can be further configured so that parity validation either occurs during the media scan or is skipped. The client uses this procedure to set these configuration options on a per-volume basis. Documented return codes: ok, error, illegalParam, noHeap, tryAlternate, invalidVolumeref, volumeOffline, ghostVolume, ssdMediaScanNotAllowed.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_set_volume_media_scan_params(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (VolumeMediaScanParamsUpdateDescriptor) – A VolumeMediaScanParamsUpdateDescriptor object that identifies the volume to be modified, as well as the media scan settings to be used for the volume. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_set_volume_params(system_id, body, **kwargs)[source]¶

This procedure updates various parameters (outside of cache-related parameters) for a particular volume as specified in the argument structure. Documented return codes: ok, illegalParam, noHeap, volumeNotExist, tryAlternate, invalidRequest, invalidVolumeref, volumeOffline, invalidReconpriority, ghostVolume.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_set_volume_params(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (VolumeParamsUpdateDescriptor) – A VolumeParamsUpdateDescriptor object that specifies the volume whose parameters are to be updated, as well as the new parameter values themselves. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_set_volume_properties(system_id, body, **kwargs)[source]¶

This procedure is used for setting new values of certain volume properties. It supports setting some properties while leaving others unchanged. Documented return codes: ok, error, illegalParam, noHeap, volumeNotExist, tryAlternate, internalError, invalidVolumeref, volumeOffline, volumeNotOptimal, invalidReconpriority, volumeNotConfigurable.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_set_volume_properties(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (VolumePropertiesUpdateDescriptor) – A VolumePropertiesUpdateDescriptor structure specifying which properties to change and what their new values should be. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_set_volume_user_label(system_id, body, **kwargs)[source]¶

This procedure is used by a client to modify the user-assigned label for a volume. The label value is stored in non-volatile storage and returned to the client as part of the Volume or SnapshotVolume object when the client requests this information from the controller. Documented return codes: ok, error, illegalParam, noHeap, tryAlternate, invalidVolumeref, volumeOffline, invalidLabel, ghostVolume, volumeNotConfigurable.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_set_volume_user_label(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (VolumeLabelUpdateDescriptor) – A VolumeLabelUpdateDescriptor object that contains the new user-assigned label for the volume. This value is presented to the controller as a variable-length opaque byte array. However, the intention is that the byte array will contain a string value in double-byte character set format, with each two bytes representing one character value. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_start_base_controller_diagnostic(system_id, body, **kwargs)[source]¶

Starts a base controller diagnostic test on the controller. Documented return codes: ok, illegalParam, diagInProgress, ctrlNotInServiceMode.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_start_base_controller_diagnostic(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (FruDiagDescriptor) – A structure containing the test type for the procedure call. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_start_cache_backup_device_diagnostic(system_id, body, **kwargs)[source]¶

Starts a cache backup device diagnostic test on the controller Documented return codes: ok, illegalParam, diagInProgress, ctrlNotInServiceMode, cacheBackupDevNotExist.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_start_cache_backup_device_diagnostic(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (FruDiagDescriptor) – A structure containing the test type and slot number for the procedure call. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_start_cache_memory_diagnostic(system_id, body, **kwargs)[source]¶

Starts a cache memory diagnostic test on the controller Documented return codes: ok, illegalParam, diagInProgress, ctrlNotInServiceMode.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_start_cache_memory_diagnostic(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (FruDiagDescriptor) – A structure containing the test type for the controller. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_start_cg_rollback(system_id, body, **kwargs)[source]¶

This procedure will initiate a rollback on a specified PiT on all members of a consistency group (all members that have the specified PiT may not necessarily be all of them). Documented return codes: ok, repositoryOffline, pitGroupsFeatureDisabled.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_start_cg_rollback(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (PITConsistencyGroupRollbackStartDescriptor) – Descriptor for the consistency group rollback to be started. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_start_channel_diagnostics(system_id, body, **kwargs)[source]¶

This procedure initiates a drive channel fault isolation diagnostic test. It returns a status code immediately and the requested tests proceed asynchronously. Any SYMbol request, other than getChannelDiagnosticsResults, cancelChannelDiagnostics, bindToController, and getSAData that is received while the test is running is rejected immediately. Since some SYMbol procedures do not provide a return code, the method of indicating the request rejection is specialized and entails the following: The RPC header that is returned to the client will consist of an RPC response of type “reply message.” The reply will have a general status of “accepted,” indicating the request was accepted by the controller for processing. The specific “accepted request status” value will be 0x80000001, which is an indication that the request could not be processed due to a diagnostic activity. Documented return codes: ok, invalidRequest, channelDiagsLockErr, channelDiagsNotQuiesced, channelDiagsAltCommFailed, channelDiagsChanSetupFailed, channelDiagsDeviceBypassFailed.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_start_channel_diagnostics(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (ChannelDiagnosticDescriptor) – A ChannelDiagnosticDescriptor structure that contains all of the arguments needed to define the test to perform. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_start_channel_identification(system_id, body, **kwargs)[source]¶

This procedure causes visual indicators to be activated on the specified channel. The indicators will remain active until the stopIdentification procedure is invoked. Documented return codes: ok, error, illegalParam, noHeap.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_start_channel_identification(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (int) – An integer value specifying the channel number. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_start_disk_pool_expansion(system_id, body, **kwargs)[source]¶

This procedure initiates a long-running operation to expand the capacity of a Disk Pool by adding one or more drives to it. Documented return codes: ok, exceedDiskPoolCapacity, exceedMaxVolumeCapacity.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_start_disk_pool_expansion(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (DiskPoolExpansionDescriptor) – A reference to the Disk Pool to expand and the drives to use for the expansion. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_start_disk_pool_reduction(system_id, body, **kwargs)[source]¶

This procedure initiates a long-running operation to reduce the capacity of a Disk Pool by removing one or more drives from it. Documented return codes: ok, drivesNotAvailableForRemoval.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_start_disk_pool_reduction(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (DiskPoolReductionDescriptor) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_start_drive_firmware_download(system_id, body, **kwargs)[source]¶

This procedure starts the parallel drive firmware download process. Documented return codes: ok, error, busy, illegalParam, noHeap, downloadNotPermitted, spawnError, downloadInProgress, sodInProgress, invalidDrives, invalidSetsize.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_start_drive_firmware_download(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (DriveFirmwareDownload) – This object contains the list of drives to download and an indicator of whether or not to perform the download keeping the volumes online. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	DriveFirmwareStatus If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_start_drive_identification(system_id, body, **kwargs)[source]¶

This procedure causes visual indicators to be activated on the physical drives specified in the argument list to allow an end-user to visually identify the drives. The indicators will remain active until the stopIdentification procedure is invoked. Documented return codes: ok, error, illegalParam, noHeap.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_start_drive_identification(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (DriveRefList) – A list of drive reference objects that specifies the drives whose visual indicators are to be activated. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_start_drive_reconstruction(system_id, body, **kwargs)[source]¶

This procedure initiates the reconstruction of a failed drive in a degraded RAID volume. The procedure returns once the reconstruction has started. If the indicated failed drive has an integrated hot spare serving in its place, then this procedure will initiate the copyback from the hot spare to the failed drive. Documented return codes: ok, error, illegalParam, noHeap, volumeReconfiguring, tryAlternate, invalidRequest, invalidDriveref, invalidRaidlevel, reconstructionInProgress, copybackInProgress.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_start_drive_reconstruction(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – The value of the drive reference for the drive on which reconstruction is to begin. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_start_flash_cache_analytics(system_id, body, **kwargs)[source]¶

This procedure starts collecting analytics data for flash cache. It resets analytics counters and begins capturing cache data. Documented return codes: ok, error, illegalParam, internalError, invalidVolumeref, notFlashcacheVol.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_start_flash_cache_analytics(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_start_host_card_diagnostic(system_id, body, **kwargs)[source]¶

Starts a host card diagnostic test on the controller Documented return codes: ok, illegalParam, diagInProgress, ctrlNotInServiceMode.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_start_host_card_diagnostic(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (FruDiagDescriptor) – A structure containing the test type and slot number for the procedure call. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_start_performance_monitor(system_id, **kwargs)[source]¶

This procedure returns the success of starting statistic data collection. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_start_performance_monitor(system_id, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_start_pit_rollback(system_id, body, **kwargs)[source]¶

This procedure will initiate a rollback on a specified list of PiTs. Note that this list could be a subset of a set of consistency group PiTs. Documented return codes: ok, repositoryOffline, invalidPitRef, pitGroupsFeatureDisabled.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_start_pit_rollback(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (PITRefList) – A list of references to PiTs for which to start the rollback. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_start_raw_data_restore(system_id, body, **kwargs)[source]¶

starts a raw data restore operation. Documented return codes: ok, busy, noHeap, tryAlternate, rawdataTransferBadType, rawdataTransferAlreadyStarted, rawdataTransferReadError, rawdataTransferNoDrives, rawdataTransferInvalidImage, dbmDbSourceUnavailable, dbmRestoreSourceMismatch.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_start_raw_data_restore(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (RawDataRestoreStartDesc) – Specifies the controller ref, data transfer type and transfer-type-specific parameters for the restore operation. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	RawDataRestoreResult If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_start_raw_data_retrieve(system_id, body, **kwargs)[source]¶

This procedure starts a raw data retrieval operation. Documented return codes: ok, busy, noHeap, invalidControllerref, rawdataTransferBadType, rawdataTransferAlreadyStarted, rawdataTransferNoDrives, dqRetrieveNothingToTransfer, dplCoreDumpInvalidTag, coredumpBackupInProgress.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_start_raw_data_retrieve(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (RawDataRetrieveStartDesc) – The controller ref and transfer-type-specific details of the retrieval. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	RawDataRetrieveStartResult If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_start_sa_identification(system_id, **kwargs)[source]¶

This procedure causes visual indicators to be activated on the physical storage array unit to allow an end-user to visually identify the storage array. The indicators will remain active until the stopIdentification procedure is invoked. Documented return codes: ok, noHeap.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_start_sa_identification(system_id, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_start_snapshot_rollback(system_id, body, **kwargs)[source]¶

This procedure is used to initiate a snapshot rollback (to base) on one or more snapshots. Documented return codes: ok, rollbackStartFailure.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_start_snapshot_rollback(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (SnapshotRefList) – A reference to the snapshots to roll back. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_start_sync_mirror(system_id, body, **kwargs)[source]¶

This procedure starts the synchronization process on a mirror. Documented return codes: ok, illegalParam, volumeNotExist, tryAlternate, internalError, invalidVolumeref, ghostVolume, invalidMirrorvol, mirrorVolNotPrimary.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_start_sync_mirror(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – The value of the mirror that is to be synchronized. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_start_tray_identification(system_id, body, **kwargs)[source]¶

This procedure causes visual indicators to be activated on the physical storage array unit to allow an end-user to visually identify the trays. The indicators will remain active until the stopIdentification procedure is invoked. Documented return codes: ok, invalidTrayref.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_start_tray_identification(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (TrayRefList) – A list of the trays. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_start_volume_copy(system_id, body, **kwargs)[source]¶

This procedure takes as its input a VolumeCopyRef and causes a copy operation to be initiated from the beginning of the Source volume. A failure status is returned if the Source and Target volumes do not meet compatibility requirements. Documented return codes: ok, illegalParam, noHeap, volumeNotExist, tryAlternate, internalError, iconFailure, invalidVolumecopyref, copyActive, copyIncompatibleSource, copyIncompatibleTarget, copyGhostSource, copyGhostTarget, copyInvalidSourceState, copyInvalidTargetState, copySourceReconfig, copyTargetReconfig, copyTargetTooSmall, copyTargetLimit, copySourceReservation, copySourceFormat, copyTargetFormat, copyStartFailed, copySourceZeroCapacity, copyApptagMismatch.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_start_volume_copy(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – A descriptor object that identifies the volumes to perform the copy operation. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_start_volume_expansion(system_id, body, **kwargs)[source]¶

This procedure checks to make sure the additional capacity is available and then starts a DVE or DCE/DVE operation. Documented return codes: ok, error, illegalParam, noHeap, driveNotUnassigned, volumeReconfiguring, tryAlternate, internalError, invalidRequest, volumeFormatting, invalidVolumeref, invalidDriveref, volumeOffline, volumeNotOptimal, invalidExpansionList, driveNotOptimal, duplicateDrives, numdrivesAdditional, numdrivesGroup, driveTooSmall, ghostVolume, cannotReconfigure, drivesDacstoresOverlap, volumeHasAsyncMirror, insufficientCache.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_start_volume_expansion(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (VolumeExpansionDescriptor) – A VolumeExpansionDescriptor object that identifies the volume to be expanded, plus the drive or drives to be added to the volume. All drives specified for this operation must be in the unassigned state initially. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_start_volume_format(system_id, body, **kwargs)[source]¶

This procedure causes the specified volume to be formatted. All data that is currently present on the volume will be irretrievably lost as a result of this operation. Once a format operation starts, the volume’s action field will be changed to VOL_ACTION_INITIALIZING; the getVolumeActionProgress procedure can then be used to monitor the progress of the operation. Volume format operations are typically required only when reviving a volume that has been marked failed for some reason. Newly-created volumes need not be explicitly formatted using this procedure. Documented return codes: ok, busy, illegalParam, noHeap, volumeNotExist, volumeReconfiguring, tryAlternate, reservationConflict, internalError, invalidRequest, invalidVolumeref, volumeOffline, ghostVolume, cannotFormatVolume.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_start_volume_format(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – The value of the volume reference for the volume that is to be reformatted. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_start_volume_group_defrag(system_id, body, **kwargs)[source]¶

This procedure initiates a long-running operation to defragment a volume group by shifting the physical storage location of each volume in the volume group to eliminate any free extents that reside between defined volumes. Note that all volumes remain fully accessible and online during this transition. While the operation is in progress, the client can make calls to the getVolumeActionProgress procedure to determine how much progress has been made in completing the operation for each affected volume. The end result of a volume group defragment operation is that free extents that existed between defined volumes will be eliminated, and a single large free extent (if any) will appear at the end of the volume group. Documented return codes: ok, error, illegalParam, noHeap, driveNotUnassigned, volumeReconfiguring, tryAlternate, invalidRequest, volumeFormatting, invalidVolumegroupref, volumeOffline, volumeNotOptimal, driveNotOptimal, duplicateDrives, numdrivesAdditional, numdrivesGroup, driveTooSmall, cannotReconfigure, drivesDacstoresOverlap, reconfigLogSpaceError, insufficientCache.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_start_volume_group_defrag(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – The value of a volume group reference for the volume group that is to be defragmented. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_start_volume_group_expansion(system_id, body, **kwargs)[source]¶

This procedure initiates a long-running operation to expand the capacity of a volume group by adding one or more drives to it. An expansion of this form requires that the controller transparently move the data of existing volumes within the volume group; volumes remain fully accessible and online during this transition. While the operation is in progress, the client can make calls to the getVolumeActionProgress procedure to determine how much progress has been made in completing the operation for each affected volume. The end result of a volume group expansion is the appearance of a new (or enlarged) free extent at the end of the volume group. The free extent can then be used to create new volumes as desired by the user. Documented return codes: ok, error, illegalParam, noHeap, driveNotUnassigned, volumeReconfiguring, tryAlternate, invalidRequest, volumeFormatting, invalidVolumegroupref, invalidDriveref, volumeOffline, volumeNotOptimal, invalidExpansionList, driveNotOptimal, duplicateDrives, numdrivesAdditional, numdrivesGroup, driveTooSmall, cannotReconfigure, drivesDacstoresOverlap, volumeHasAsyncMirror, reconfigLogSpaceError, insufficientCache.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_start_volume_group_expansion(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (VolumeGroupExpansionDescriptor) – A VolumeGroupExpansionDescriptor object that identifies the volume group to be expanded, plus the drive or drives to be added to the volume group. All drives specified for this operation must be in the unassigned state initially. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_start_volume_parity_check(system_id, body, **kwargs)[source]¶

Initiates an explicit parity check operation. This is a background task that verifies the correctness of all parity/redundancy data for the volume. Only one such operation may be active at any time on a given controller. After initiating the operation with this procedure, the operation’s progress can be checked via the getParityCheckProgress procedure. This procedure is deprecated. The scanVolume procedure should be used instead. Documented return codes: ok, noHeap, tryAlternate, background, invalidVolumeref, volumeOffline, volumeNotOptimal, invalidRaidlevel, parityScanInProgress, ghostVolume.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_start_volume_parity_check(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – The AbstractVolRef of the volume on which the operation is to be performed. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_start_volume_raid_migration(system_id, body, **kwargs)[source]¶

This procedure initiates a long-running operation to change the RAID level of a volume group (and thus all volumes in the volume group) from one supported value to another. While the operation is in progress, the client can make calls to the getVolumeActionProgress procedure to determine how much progress has been made in completing the operation for each affected volume. Documented return codes: ok, error, illegalParam, noHeap, driveNotUnassigned, volumeReconfiguring, tryAlternate, invalidRequest, volumeFormatting, invalidVolumegroupref, volumeOffline, invalidRaidlevel, driveNotOptimal, duplicateDrives, numdrivesAdditional, numdrivesGroup, cannotReconfigure, drivesDacstoresOverlap, insufficientCache.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_start_volume_raid_migration(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (VolumeRAIDMigrationDescriptor) – A VolumeRAIDMigrationDescriptor object that identifies the volume group and the new RAID level to be used. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_start_volume_segment_sizing(system_id, body, **kwargs)[source]¶

This procedure initiates a long-running operation to change the segment size (i.e. stripe depth) of a volume from one supported value to another. While the operation is in progress, the client can make calls to the getVolumeActionProgress procedure to determine how much progress has been made in completing the operation. Documented return codes: ok, error, illegalParam, noHeap, volumeReconfiguring, tryAlternate, reservationConflict, invalidRequest, volumeFormatting, invalidVolumeref, volumeOffline, invalidSegmentsize, ghostVolume, cannotReconfigure, drivesDacstoresOverlap, insufficientCache.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_start_volume_segment_sizing(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (VolumeSegmentSizingDescriptor) – A VolumeSegmentSizingDescriptor object that identifies the volume and the new segment size to be used. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_state_capture(system_id, body, **kwargs)[source]¶

This procedure is used to capture current controller conditions as specified by the function being passed through the variable string input. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_state_capture(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – A character string indicating the function being called and up to 2 function arguments. The individual elements of the string are separated by commas. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	ReturnCodeWithOpaqueData If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_stop_channel_diagnostics(system_id, **kwargs)[source]¶

This procedure cancels a running channel diagnostic test sequence that was initiated by the startChannelDiagnostics procedure. It is possible to retrieve the (partial) results of a canceled test by calling getChannelDiagnosticsResults. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_stop_channel_diagnostics(system_id, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_stop_drive_firmware_download(system_id, **kwargs)[source]¶

This procedure stops the parallel drive firmware download process. Documented return codes: ok, error, illegalParam, tryAlternate, invalidRequest.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_stop_drive_firmware_download(system_id, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_stop_flash_cache_analytics(system_id, body, **kwargs)[source]¶

This procedure stops the collection of analytics data for flash cache. It disables the collection of cache hits. Documented return codes: ok, error, illegalParam, internalError, invalidVolumeref, notFlashcacheVol.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_stop_flash_cache_analytics(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_stop_identification(system_id, **kwargs)[source]¶

This procedure cancels the effects of any prior startDriveIdentification, startSAIdentification, startChannelIdentification and/or startTrayIdentification operations by deactivating all visual indicators. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_stop_identification(system_id, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_stop_iscsi_session(system_id, body, **kwargs)[source]¶

This procedure forcibly terminates an iSCSI session. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_stop_iscsi_session(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (int) – An TargetSessionIdentifyingHandle object indicating which session to terminate. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_stop_performance_monitor(system_id, **kwargs)[source]¶

This procedure returns the success of stopping statistic data collection. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_stop_performance_monitor(system_id, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_stop_pit_consistency_group_view(system_id, body, **kwargs)[source]¶

This procedure will stop the specified PITConsistencyGroupView (and thus all of its associated member views). Documented return codes: ok, operationFailedVolumeCopyClone.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_stop_pit_consistency_group_view(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (PITConsistencyGroupViewStopDescriptor) – An object containing all of the attributes required to stop a PiT Consistency Group View. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_stop_pit_view(system_id, body, **kwargs)[source]¶

This procedure will stop an existing PiT View. Documented return codes: ok, operationFailedVolumeCopyClone.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_stop_pit_view(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – Reference to PiT View to be stopped. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_stop_volume_copy(system_id, body, **kwargs)[source]¶

This procedure halts the active copy. Documented return codes: ok, illegalParam, noHeap, volumeNotExist, tryAlternate, internalError, invalidVolumecopyref, copyInactive, copyStopFailed.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_stop_volume_copy(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – The VolumeCopyRef object to halt the active copy. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_suspend_async_mirror_group(system_id, body, **kwargs)[source]¶

This procedure will suspend an Async Mirror Group. Documented return codes: ok, arvmGroupDoesNotExist, arvmRecoveryPointDeletionRequired, arvmGroupNotPrimary, arvmMemberFailed, arvmSuspendFailure, arvmOrphanGroup, remoteInternalError, arvmRemoteGroupDoesNotExist, remoteDatabaseError, arvmRemoteSuspendFailure.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_suspend_async_mirror_group(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (AsyncMirrorGroupSuspendDescriptor) – A descriptor that lists the AMG on which the synchronization is to be suspended. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	AsyncMirrorGroupActionResult If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_suspend_consistency_group(system_id, body, **kwargs)[source]¶

This procedure suspends the communications for all mirrors in a Write Consistency group with a specified group number. Documented return codes: ok, noHeap, internalError, iconFailure, rvmQuiescenceInProgress, legacyRvmAsyncModeUnsupported.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_suspend_consistency_group(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – This object contains information about the write consistency group object. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_suspend_flash_cache(system_id, body, **kwargs)[source]¶

This procedure suspends caching on the specified flash cache. Documented return codes: ok, error, illegalParam, noHeap, volumeNotExist, internalError, invalidVolumeref, flashcacheAlreadySuspended, notFlashcacheVol, flashcacheDeleted.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_suspend_flash_cache(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – The flash cache reference. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_suspend_mirror(system_id, body, **kwargs)[source]¶

This procedure suspends the communication between a mirror pair. Documented return codes: ok, illegalParam, noHeap, tryAlternate, internalError, iconFailure, invalidVolumeref, ghostVolume, invalidMirrorvol, rvmVersionMismatch, rvmOperNotAllowedOnSec, mirrorAlreadySuspended.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_suspend_mirror(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – This object contains information identifying the Mirror Proxy Volume to be removed. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_suspend_mirror_list(system_id, body, **kwargs)[source]¶

This procedure suspends the communication between all mirrored pairs specified in the MirrorVolumeList. Documented return codes: ok, noHeap, internalError, iconFailure, rvmQuiescenceInProgress.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_suspend_mirror_list(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (MirrorVolumeList) – This object contains information identifying the list of Mirror Volumes to suspend. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_synchronize_async_mirror_group(system_id, body, **kwargs)[source]¶

This procedure will start a manual resynchronization on an Async Mirror Group. Documented return codes: ok, arvmGroupDoesNotExist, arvmRecoveryPointDeletionRequired, arvmGroupNotPrimary, arvmSynchronizeFailure, arvmInvalidAmgRequestWhileSuspended, arvmManualSyncAlreadyInProgress, arvmManualSyncRetryTooSoon, arvmOrphanGroup, remoteInternalError, arvmRemoteGroupDoesNotExist, remoteDatabaseError, arvmRemoteSynchronizeFailure, arvmExpansionSynchronizationInProgress.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_synchronize_async_mirror_group(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (AsyncMirrorGroupSynchronizeDescriptor) – A reference to the Asynchronous Mirror Group to synchronize. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	AsyncMirrorGroupActionResult If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

netapp.santricity.api.symbol.t_api module¶

TApi.py

class netapp.santricity.api.symbol.t_api.TApi(api_client=None)[source]¶

Bases: object

symbol_test_async_mirror_group_connectivity(system_id, body, **kwargs)[source]¶

This procedure is used to initiate an Async Mirror Group link connectivity test. Documented return codes: ok, arvmConnectivityTestNetworkError, arvmConnectivityTestRemoteTimeout, arvmConnectivityTestLoginFailure, arvmConnectivityTestNameServiceError, arvmConnectivityTestTurError, arvmConnectivityTestMissingRemoteAmg, arvmConnectivityTestAmgMemberMismatch, arvmConnectivityTestTimeoutExceeded, remoteNoHeap, arvmRemoteGroupDoesNotExist.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_test_async_mirror_group_connectivity(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (AsyncMirrorGroupConnectivityTestDescriptor) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	AsyncMirrorGroupConnectivityTestResultsReturned If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_test_snmp_trap_destination(system_id, body, **kwargs)[source]¶

This procedure is used to test SNMP trap destinations (generate test trap). Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_test_snmp_trap_destination(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (SNMPTrapDestinationTestDescriptorList) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_trigger_dpl_core_dump_on_demand(system_id, **kwargs)[source]¶

This procedure is used to manually trigger a DPL Core Dump. Documented return codes: ok.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_trigger_dpl_core_dump_on_demand(system_id, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	DPLCoreDumpOnDemandReturn If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_trigger_ioc_dump_on_demand(system_id, body, **kwargs)[source]¶

This procedure is used to manually trigger an IOC Dump on the specified channel. Documented return codes: ok, iocDumpInProgress, iocRestoreInProgress.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_trigger_ioc_dump_on_demand(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (ChannelLocation) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	IOCDumpOnDemandReturn If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_trim_concat_volume(system_id, body, **kwargs)[source]¶

This procedure will trim a concatenated volume by removing one or more member RAID volumes. Note this can only be done in cases where the ConcatVolume is not being used (definition of “used” depends on parent object usage). Documented return codes: ok, invalidTrimCount, volumeInUse.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_trim_concat_volume(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (ConcatVolumeTrimDescriptor) – A descriptor of the concat volume to be trimmed. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

netapp.santricity.api.symbol.u_api module¶

UApi.py

class netapp.santricity.api.symbol.u_api.UApi(api_client=None)[source]¶

Bases: object

symbol_unquiesce_controller(system_id, body, **kwargs)[source]¶

This procedure is used to take a controller out of the quiesced state. Documented return codes: ok, error, illegalParam, invalidControllerref.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_unquiesce_controller(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (str) – A value of the controller to take out of the quiesced state. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_update_drive_firmware(system_id, **kwargs)[source]¶

This procedure starts the drive download stage of the parallel drive firmware download process. Documented return codes: ok, error, illegalParam, invalidRequest.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_update_drive_firmware(system_id, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_update_psu_firmware(system_id, body, **kwargs)[source]¶

This procedure is used to update the firmware on one or more power supplies. Documented return codes: ok, psuFirmwareDownloadFailed, psuFirmwareUpdateMfgDeviceCodeMismatch, psuFirmwareUpdateNotAllRedundant, psuFirmwareUpdateNotAllOptimal.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_update_psu_firmware(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (PSUFirmwareUpdateDescriptor) – A PSUFirmwareUpdateDescriptor object that contains all the attributes required to update the firmware on the power supplies. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_update_tray(system_id, body, **kwargs)[source]¶

Updates the Tray ID of a tray. Documented return codes: ok, error, illegalParam, noHeap.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_update_tray(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (TrayUpdateDescriptor) – A reference to the physical tray and the ID value to set for the tray. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_update_volume_attribute(system_id, body, **kwargs)[source]¶

This procedure changes the mgmtClientAttribute for a volume. Documented return codes: ok, noHeap, volumeNotExist, databaseError.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_update_volume_attribute(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (VolumeAttributeUpdateDescriptor) – The VolumeAttributeUpdateDescriptor object. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

netapp.santricity.api.symbol.v_api module¶

VApi.py

class netapp.santricity.api.symbol.v_api.VApi(api_client=None)[source]¶

Bases: object

symbol_validate_lock_key(system_id, body, **kwargs)[source]¶

Used to validate the supplied key with one currently on the controller. Documented return codes: ok, invalidBlob, noMatchingLockKeyIdFound, lockKeyValidationFailed, lockKeyValidationDisabled, externalKeyNotInMemory.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_validate_lock_key(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (LockKeyBlob) – A LockKeyBlob structure that contains the wrapped lock key and the pass phrase used to encrypt the lock key. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_validate_password(system_id, **kwargs)[source]¶

This procedure validates the clients storage array password and reports a return code indicating whether or not the password is valid. Even though it does not modify the state of the array, this procedure behaves the same and has the same setup requirements as a procedure that does modify the state of the array. Documented return codes: ok, authFailPassword, authFailReadpassword.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_validate_password(system_id, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

netapp.santricity.api.symbol.w_api module¶

WApi.py

class netapp.santricity.api.symbol.w_api.WApi(api_client=None)[source]¶

Bases: object

symbol_write_client_mgmt_records_no_password(system_id, body, **kwargs)[source]¶

This procedure saves a new value of the specified MgmtClientRecords. Documented return codes: ok, noHeap, volumeNotExist, databaseError.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_write_client_mgmt_records_no_password(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (MgmtClientRecordWriteDescriptor) – The MgmtClientRecordWriteDescriptor object. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

symbol_write_mgmt_client_records(system_id, body, **kwargs)[source]¶

This procedure saves a new value of the specified MgmtClientRecord. Documented return codes: ok, noHeap, volumeNotExist, databaseError.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response. >>> def callback_function(response): >>> pprint(response) >>>

>>> thread = api.symbol_write_mgmt_client_records(system_id, body, callback=callback_function)

Parameters:	function (callback) – The callback function for asynchronous request. (optional) system_id (str) – (required) body (MgmtClientRecordWriteDescriptor) – The MgmtClientRecordWriteDescriptor object. (required) controller (str) – Controller selection verbose_error_response (bool) –
Returns:	str If the method is called asynchronously, returns the request thread.
Raises:	ValueError If the required params are not provided or if the response data format is unknown. TypeError: When the data type of response data is different from what we are expecting ApiException: Occurs when we get a HTTP error code (422 and above).

Table Of Contents

Previous topic

Next topic

This Page

netapp.santricity.api.symbol package¶

Submodules¶

netapp.santricity.api.symbol.a_api module¶

netapp.santricity.api.symbol.b_api module¶

netapp.santricity.api.symbol.c_api module¶

netapp.santricity.api.symbol.d_api module¶

netapp.santricity.api.symbol.e_api module¶

netapp.santricity.api.symbol.f_api module¶

netapp.santricity.api.symbol.g_api module¶

netapp.santricity.api.symbol.i_api module¶

netapp.santricity.api.symbol.l_api module¶

netapp.santricity.api.symbol.m_api module¶

netapp.santricity.api.symbol.p_api module¶

netapp.santricity.api.symbol.q_api module¶

netapp.santricity.api.symbol.r_api module¶

netapp.santricity.api.symbol.s_api module¶

netapp.santricity.api.symbol.t_api module¶

netapp.santricity.api.symbol.u_api module¶

netapp.santricity.api.symbol.v_api module¶

netapp.santricity.api.symbol.w_api module¶

Module contents¶