:type virtualNetworkTag: int
:param virtualNetworkIDs: Network IDs to include in the list.
:type virtualNetworkIDs: int
:param virtualNetworkTags: Network tag to include in the list.
:type virtualNetworkTags: int
"""
self._check_connection_type("list_virtual_networks", "Cluster")
params = {
}
if virtual_network_id is not None:
params["virtualNetworkID"] = virtual_network_id
if virtual_network_tag is not None:
params["virtualNetworkTag"] = virtual_network_tag
if virtual_network_ids is not None:
params["virtualNetworkIDs"] = virtual_network_ids
if virtual_network_tags is not None:
params["virtualNetworkTags"] = virtual_network_tags
# There is no adaptor.
return self.send_request(
'ListVirtualNetworks',
ListVirtualNetworksResult,
params,
since=7.0
)
[docs] def modify_virtual_network(
self,
virtual_network_id=OPTIONAL,
virtual_network_tag=OPTIONAL,
name=OPTIONAL,
address_blocks=OPTIONAL,
netmask=OPTIONAL,
svip=OPTIONAL,
gateway=OPTIONAL,
namespace=OPTIONAL,
attributes=OPTIONAL,):
"""
You can use ModifyVirtualNetwork to change the attributes of an existing virtual network. This method enables you to add or remove
address blocks, change the netmask, or modify the name or description of the virtual network. You can also use it to enable or
disable namespaces, as well as add or remove a gateway if namespaces are enabled on the virtual network.
Note: This method requires either the VirtualNetworkID or the VirtualNetworkTag as a parameter, but not both.
Caution: Enabling or disabling the Routable Storage VLANs functionality for an existing virtual network by changing the
"namespace" parameter disrupts any traffic handled by the virtual network. NetApp strongly recommends changing the
"namespace" parameter only during a scheduled maintenance window.
:param virtualNetworkID: The unique identifier of the virtual network to modify. This is the virtual network ID assigned by the cluster. Note: This parameter is optional but either virtualNetworkID or virtualNetworkTag must be specified with this API method.
:type virtualNetworkID: int
:param virtualNetworkTag: The network tag that identifies the virtual network to modify. Note: This parameter is optional but either virtualNetworkID or virtualNetworkTag must be specified with this API method.
:type virtualNetworkTag: int
:param name: The new name for the virtual network.
:type name: str
:param addressBlocks: The new addressBlock to set for this virtual network. This might contain new address blocks to add to the existing object or omit unused address blocks that need to be removed. Alternatively, you can extend or reduce the size of existing address blocks. You can only increase the size of the starting addressBlocks for a virtual network object; you can never decrease it. Attributes for this parameter are: start: The start of the IP address range. (String) size: The number of IP addresses to include in the block. (Integer)
:type addressBlocks: AddressBlockParams
:param netmask: New network mask for this virtual network.
:type netmask: str
:param svip: The storage virtual IP address for this virtual network. The svip for a virtual network cannot be changed. You must create a new virtual network to use a different svip address.
:type svip: str
:param gateway: The IP address of a gateway of the virtual network. This parameter is only valid if the "namespace" parameter is set to true.
:type gateway: str
:param namespace: When set to true, enables Routable Storage VLANs functionality by recreating the virtual network and configuring a namespace to contain it. When set to false, disables the VRF functionality for the virtual network. Changing this value disrupts traffic running through this virtual network.
:type namespace: bool
:param attributes: A new list of name-value pairs in JSON object format.
:type attributes: dict
"""
self._check_connection_type("modify_virtual_network", "Cluster")
params = {
}
if virtual_network_id is not None:
params["virtualNetworkID"] = virtual_network_id
if virtual_network_tag is not None:
params["virtualNetworkTag"] = virtual_network_tag
if name is not None:
params["name"] = name
if address_blocks is not None:
params["addressBlocks"] = address_blocks
if netmask is not None:
params["netmask"] = netmask
if svip is not None:
params["svip"] = svip
if gateway is not None:
if self.api_version < 9.0:
raise ApiParameterVersionError("modify_virtual_network", 9.0,
[("gateway", gateway, 9.0, False)])
else:
params["gateway"] = gateway
if namespace is not None:
if self.api_version < 9.0:
raise ApiParameterVersionError("modify_virtual_network", 9.0,
[("namespace", namespace, 9.0, False)])
else:
params["namespace"] = namespace
if attributes is not None:
params["attributes"] = attributes
# There is no adaptor.
return self.send_request(
'ModifyVirtualNetwork',
AddVirtualNetworkResult,
params,
since=7.0
)
[docs] def remove_virtual_network(
self,
virtual_network_id=OPTIONAL,
virtual_network_tag=OPTIONAL,):
"""
RemoveVirtualNetwork enables you to remove a previously added virtual network.
Note: This method requires either the virtualNetworkID or the virtualNetworkTag as a parameter, but not both.
:param virtualNetworkID: Network ID that identifies the virtual network to remove.
:type virtualNetworkID: int
:param virtualNetworkTag: Network tag that identifies the virtual network to remove.
:type virtualNetworkTag: int
"""
self._check_connection_type("remove_virtual_network", "Cluster")
params = {
}
if virtual_network_id is not None:
params["virtualNetworkID"] = virtual_network_id
if virtual_network_tag is not None:
params["virtualNetworkTag"] = virtual_network_tag
# There is no adaptor.
return self.send_request(
'RemoveVirtualNetwork',
RemoveVirtualNetworkResult,
params,
since=7.0
)
[docs] def enable_feature(
self,
feature,):
"""
You can use EnableFeature to enable cluster features that are disabled by default.
:param feature: [required] Indicates which feature to enable. Valid value is: vvols: Enable the NetApp SolidFire VVols cluster feature.
:type feature: str
"""
self._check_connection_type("enable_feature", "Cluster")
params = {
"feature": feature,
}
# There is no adaptor.
return self.send_request(
'EnableFeature',
EnableFeatureResult,
params,
since=9.0
)
[docs] def get_feature_status(
self,
feature=OPTIONAL,):
"""
GetFeatureStatus enables you to retrieve the status of a cluster feature.
:param feature: Specifies the feature for which the status is returned. Valid value is: vvols: Retrieve status for the NetApp SolidFire VVols cluster feature.
:type feature: str
"""
self._check_connection_type("get_feature_status", "Cluster")
params = {
}
if feature is not None:
params["feature"] = feature
# There is no adaptor.
return self.send_request(
'GetFeatureStatus',
GetFeatureStatusResult,
params,
since=9.0
)
[docs] def get_virtual_volume_count(
self,):
"""
Enables retrieval of the number of virtual volumes currently in the system. """
self._check_connection_type("get_virtual_volume_count", "Cluster")
params = {
}
# There is no adaptor.
return self.send_request(
'GetVirtualVolumeCount',
GetVirtualVolumeCountResult,
params,
since=9.0
)
[docs] def list_protocol_endpoints(
self,
protocol_endpoint_ids=OPTIONAL,):
"""
ListProtocolEndpoints enables you to retrieve information about all protocol endpoints in the cluster. Protocol endpoints govern
access to their associated virtual volume storage containers.
:param protocolEndpointIDs: A list of protocol endpoint IDs for which to retrieve information. If you omit this parameter, the method returns information about all protocol endpoints.
:type protocolEndpointIDs: UUID
"""
self._check_connection_type("list_protocol_endpoints", "Cluster")
params = {
}
if protocol_endpoint_ids is not None:
params["protocolEndpointIDs"] = protocol_endpoint_ids
# There is no adaptor.
return self.send_request(
'ListProtocolEndpoints',
ListProtocolEndpointsResult,
params,
since=9.0
)
[docs] def list_virtual_volume_bindings(
self,
virtual_volume_binding_ids=OPTIONAL,):
"""
ListVirtualVolumeBindings returns a list of all virtual volumes in the cluster that are bound to protocol endpoints.
:param virtualVolumeBindingIDs: A list of virtual volume binding IDs for which to retrieve information. If you omit this parameter, the method returns information about all virtual volume bindings.
:type virtualVolumeBindingIDs: int
"""
self._check_connection_type("list_virtual_volume_bindings", "Cluster")
params = {
}
if virtual_volume_binding_ids is not None:
params["virtualVolumeBindingIDs"] = virtual_volume_binding_ids
# There is no adaptor.
return self.send_request(
'ListVirtualVolumeBindings',
ListVirtualVolumeBindingsResult,
params,
since=9.0
)
[docs] def list_virtual_volume_hosts(
self,
virtual_volume_host_ids=OPTIONAL,):
"""
ListVirtualVolumeHosts returns a list of all virtual volume hosts known to the cluster. A virtual volume host is a VMware ESX host
that has initiated a session with the VASA API provider.
:param virtualVolumeHostIDs: A list of virtual volume host IDs for which to retrieve information. If you omit this parameter, the method returns information about all virtual volume hosts.
:type virtualVolumeHostIDs: UUID
"""
self._check_connection_type("list_virtual_volume_hosts", "Cluster")
params = {
}
if virtual_volume_host_ids is not None:
params["virtualVolumeHostIDs"] = virtual_volume_host_ids
# There is no adaptor.
return self.send_request(
'ListVirtualVolumeHosts',
ListVirtualVolumeHostsResult,
params,
since=9.0
)
[docs] def list_virtual_volumes(
self,
details=OPTIONAL,
limit=OPTIONAL,
recursive=OPTIONAL,
start_virtual_volume_id=OPTIONAL,
virtual_volume_ids=OPTIONAL,):
"""
ListVirtualVolumes enables you to list the virtual volumes currently in the system. You can use this method to list all virtual volumes,
or only list a subset.
:param details: Specifies the level of detail about each virtual volume that is returned. Possible values are: true: Include more details about each virtual volume in the response. false: Include the standard level of detail about each virtual volume in the response.
:type details: bool
:param limit: The maximum number of virtual volumes to list.
:type limit: int
:param recursive: Specifies whether to include information about the children of each virtual volume in the response. Possible values are: true: Include information about the children of each virtual volume in the response. false: Do not include information about the children of each virtual volume in the response.
:type recursive: bool
:param startVirtualVolumeID: The ID of the virtual volume at which to begin the list.
:type startVirtualVolumeID: UUID
:param virtualVolumeIDs: A list of virtual volume IDs for which to retrieve information. If you specify this parameter, the method returns information about only these virtual volumes.
:type virtualVolumeIDs: UUID
"""
self._check_connection_type("list_virtual_volumes", "Cluster")
params = {
}
if details is not None:
params["details"] = details
if limit is not None:
params["limit"] = limit
if recursive is not None:
params["recursive"] = recursive
if start_virtual_volume_id is not None:
params["startVirtualVolumeID"] = start_virtual_volume_id
if virtual_volume_ids is not None:
params["virtualVolumeIDs"] = virtual_volume_ids
# There is no adaptor.
return self.send_request(
'ListVirtualVolumes',
ListVirtualVolumesResult,
params,
since=9.0
)
[docs] def list_virtual_volume_tasks(
self,
virtual_volume_task_ids=OPTIONAL,):
"""
ListVirtualVolumeTasks returns a list of virtual volume tasks in the system.
:param virtualVolumeTaskIDs: A list of virtual volume task IDs for which to retrieve information. If you omit this parameter, the method returns information about all virtual volume tasks.
:type virtualVolumeTaskIDs: UUID
"""
self._check_connection_type("list_virtual_volume_tasks", "Cluster")
params = {
}
if virtual_volume_task_ids is not None:
params["virtualVolumeTaskIDs"] = virtual_volume_task_ids
# There is no adaptor.
return self.send_request(
'ListVirtualVolumeTasks',
ListVirtualVolumeTasksResult,
params,
since=9.0
)
[docs] def list_volume_stats_by_virtual_volume(
self,
virtual_volume_ids=OPTIONAL,):
"""
ListVolumeStatsByVirtualVolume enables you to list volume statistics for any volumes in the system that are associated with virtual volumes. Statistics are cumulative from the creation of the volume.
:param virtualVolumeIDs: A list of one or more virtual volume IDs for which to retrieve information. If you specify this parameter, the method returns information about only these virtual volumes.
:type virtualVolumeIDs: UUID
"""
self._check_connection_type("list_volume_stats_by_virtual_volume", "Cluster")
params = {
}
if virtual_volume_ids is not None:
params["virtualVolumeIDs"] = virtual_volume_ids
# There is no adaptor.
return self.send_request(
'ListVolumeStatsByVirtualVolume',
ListVolumeStatsByVirtualVolumeResult,
params,
since=9.0
)
[docs] def add_volumes_to_volume_access_group(
self,
volume_access_group_id,
volumes,):
"""
AddVolumesToVolumeAccessGroup enables you to add
volumes to a specified volume access group.
:param volumeAccessGroupID: [required] The ID of the volume access group to which volumes are added.
:type volumeAccessGroupID: int
:param volumes: [required] The list of volumes to add to the volume access group.
:type volumes: int
"""
self._check_connection_type("add_volumes_to_volume_access_group", "Cluster")
params = {
"volumeAccessGroupID": volume_access_group_id,
"volumes": volumes,
}
# There is no adaptor.
return self.send_request(
'AddVolumesToVolumeAccessGroup',
ModifyVolumeAccessGroupResult,
params,
since=5.0
)
[docs] def cancel_clone(
self,
clone_id,):
"""
CancelClone enables you to stop an ongoing CloneVolume or CopyVolume process. When you cancel a group clone operation, the
system completes and removes the operation's associated asyncHandle.
:param cloneID: [required] The cloneID for the ongoing clone process.
:type cloneID: int
"""
self._check_connection_type("cancel_clone", "Cluster")
params = {
"cloneID": clone_id,
}
# There is no adaptor.
return self.send_request(
'CancelClone',
CancelCloneResult,
params,
since=9.0
)
[docs] def cancel_group_clone(
self,
group_clone_id,):
"""
CancelGroupClone enables you to stop an ongoing CloneMultipleVolumes process occurring on a group of volumes. When you cancel
a group clone operation, the system completes and removes the operation's associated asyncHandle.
:param groupCloneID: [required] The cloneID for the ongoing clone process.
:type groupCloneID: int
"""
self._check_connection_type("cancel_group_clone", "Cluster")
params = {
"groupCloneID": group_clone_id,
}
# There is no adaptor.
return self.send_request(
'CancelGroupClone',
CancelGroupCloneResult,
params,
since=9.0
)
[docs] def clone_multiple_volumes(
self,
volumes,
access=OPTIONAL,
group_snapshot_id=OPTIONAL,
new_account_id=OPTIONAL,):
"""
CloneMultipleVolumes enables you to create a clone of a group of specified volumes. You can assign a consistent set of characteristics
to a group of multiple volumes when they are cloned together.
Before using groupSnapshotID to clone the volumes in a group snapshot, you must create the group snapshot by using the
CreateGroupSnapshot API method or the Element OS Web UI. Using groupSnapshotID is optional when cloning multiple volumes.
Note: Cloning multiple volumes is allowed if cluster fullness is at stage 2 or 3. Clones are not created when cluster fullness is
at stage 4 or 5.
:param volumes: [required] Unique ID for each volume to include in the clone. If optional parameters are not specified, the values are inherited from the source volumes. Required parameter for "volumes" array: volumeID Optional parameters for "volumes" array: access: Can be one of readOnly, readWrite, locked, or replicationTarget attributes: List of name-value pairs in JSON object format. name: New name for the clone. newAccountID: Account ID for the new volumes. newSize: New size Total size of the volume, in bytes. Size is rounded up to the nearest 1MB.
:type volumes: CloneMultipleVolumeParams
:param access: New default access method for the new volumes if not overridden by information passed in the volume's array.
:type access: str
:param groupSnapshotID: ID of the group snapshot to use as a basis for the clone.
:type groupSnapshotID: int
:param newAccountID: New account ID for the volumes if not overridden by information passed in the volumes array.
:type newAccountID: int
"""
self._check_connection_type("clone_multiple_volumes", "Cluster")
params = {
"volumes": volumes,
}
if access is not None:
params["access"] = access
if group_snapshot_id is not None:
params["groupSnapshotID"] = group_snapshot_id
if new_account_id is not None:
params["newAccountID"] = new_account_id
# There is no adaptor.
return self.send_request(
'CloneMultipleVolumes',
CloneMultipleVolumesResult,
params,
since=7.0
)
[docs] def clone_volume(
self,
volume_id,
name,
new_account_id=OPTIONAL,
new_size=OPTIONAL,
access=OPTIONAL,
snapshot_id=OPTIONAL,
attributes=OPTIONAL,
enable512e=OPTIONAL,):
"""
CloneVolume enables you to create a copy of a volume. This method is asynchronous and might take a variable amount of time to complete. The cloning process begins immediately when you make the CloneVolume request and is representative of the state of the volume when the API method is issued. You can use the GetAsyncResult method to determine when the cloning process is complete and the new volume is available for connections. You can use ListSyncJobs to see the progress of creating the clone.
Note: The initial attributes and QoS settings for the volume are inherited from the volume being cloned. You can change these settings with ModifyVolume.
Note: Cloned volumes do not inherit volume access group memberships from the source volume.
:param volumeID: [required] VolumeID for the volume to be cloned.
:type volumeID: int
:param name: [required] The name of the new cloned volume. Might be 1 to 64 characters in length.
:type name: str
:param newAccountID: AccountID for the owner of the new volume. If unspecified, the accountID of the owner of the volume being cloned is used.
:type newAccountID: int
:param newSize: New size of the volume, in bytes. Might be greater or less than the size of the volume being cloned. If unspecified, the volume size is not changed. Size is rounded to the nearest 1MB.
:type newSize: int
:param access: Specifies the level of access allowed for the new volume. Possible values are: readOnly: Only read operations are allowed. readWrite: Reads and writes are allowed. locked: No reads or writes are allowed. If unspecified, the level of access of the volume being cloned is used. replicationTarget: Identify a volume as the target volume for a paired set of volumes. If the volume is not paired, the access status is locked. If a value is not specified, the access value does not change.
:type access: str
:param snapshotID: ID of the snapshot that is used as the source of the clone. If no ID is provided, the current active volume is used.
:type snapshotID: int
:param attributes: List of name-value pairs in JSON object format.
:type attributes: dict
:param enable512e: Should the volume provide 512-byte sector emulation?
:type enable512e: bool
"""
self._check_connection_type("clone_volume", "Cluster")
params = {
"volumeID": volume_id,
"name": name,
}
if new_account_id is not None:
params["newAccountID"] = new_account_id
if new_size is not None:
params["newSize"] = new_size
if access is not None:
params["access"] = access
if snapshot_id is not None:
params["snapshotID"] = snapshot_id
if attributes is not None:
params["attributes"] = attributes
if enable512e is not None:
params["enable512e"] = enable512e
# There is no adaptor.
return self.send_request(
'CloneVolume',
CloneVolumeResult,
params,
since=1.0
)
[docs] def copy_volume(
self,
volume_id,
dst_volume_id,
snapshot_id=OPTIONAL,):
"""
CopyVolume enables you to overwrite the data contents of an existing volume with the data contents of another volume (or
snapshot). Attributes of the destination volume such as IQN, QoS settings, size, account, and volume access group membership are
not changed. The destination volume must already exist and must be the same size as the source volume.
NetApp strongly recommends that clients unmount the destination volume before the CopyVolume operation begins. If the
destination volume is modified during the copy operation, the changes will be lost.
This method is asynchronous and may take a variable amount of time to complete. You can use the GetAsyncResult method to
determine when the process has finished, and ListSyncJobs to see the progress of the copy.
:param volumeID: [required] VolumeID of the volume to be read from.
:type volumeID: int
:param dstVolumeID: [required] VolumeID of the volume to be overwritten.
:type dstVolumeID: int
:param snapshotID: ID of the snapshot that is used as the source of the clone. If no ID is provided, the current active volume is used.
:type snapshotID: int
"""
self._check_connection_type("copy_volume", "Cluster")
params = {
"volumeID": volume_id,
"dstVolumeID": dst_volume_id,
}
if snapshot_id is not None:
params["snapshotID"] = snapshot_id
# There is no adaptor.
return self.send_request(
'CopyVolume',
CopyVolumeResult,
params,
since=9.0
)
[docs] def create_volume(
self,
name,
account_id,
total_size,
enable512e,
qos=OPTIONAL,
attributes=OPTIONAL,):
"""
CreateVolume enables you to create a new (empty) volume on the cluster. As soon as the volume creation is complete, the volume is
available for connection via iSCSI.
:param name: [required] The name of the volume access group (might be user specified). Not required to be unique, but recommended. Might be 1 to 64 characters in length.
:type name: str
:param accountID: [required] AccountID for the owner of this volume.
:type accountID: int
:param totalSize: [required] Total size of the volume, in bytes. Size is rounded up to the nearest 1MB size.
:type totalSize: int
:param enable512e: [required] Specifies whether 512e emulation is enabled or not. Possible values are: true: The volume provides 512-byte sector emulation. false: 512e emulation is not enabled.
:type enable512e: bool
:param qos: Initial quality of service settings for this volume. Default values are used if none are specified. Valid settings are: minIOPS maxIOPS burstIOPS You can get the default values for a volume by using the GetDefaultQoS method.
:type qos: QoS
:param attributes: The list of name-value pairs in JSON object format. Total attribute size must be less than 1000B, or 1KB, including JSON formatting characters.
:type attributes: dict
"""
self._check_connection_type("create_volume", "Cluster")
params = {
"name": name,
"accountID": account_id,
"totalSize": total_size,
"enable512e": enable512e,
}
if qos is not None:
params["qos"] = qos
if attributes is not None:
params["attributes"] = attributes
# There is no adaptor.
return self.send_request(
'CreateVolume',
CreateVolumeResult,
params,
since=1.0
)
[docs] def delete_volume(
self,
volume_id,):
"""
DeleteVolume marks an active volume for deletion. When marked, the volume is purged (permanently deleted) after the cleanup
interval elapses. After making a request to delete a volume, any active iSCSI connections to the volume are immediately terminated
and no further connections are allowed while the volume is in this state. A marked volume is not returned in target discovery
requests.
Any snapshots of a volume that has been marked for deletion are not affected. Snapshots are kept until the volume is purged from
the system.
If a volume is marked for deletion and has a bulk volume read or bulk volume write operation in progress, the bulk volume read or
write operation is stopped.
If the volume you delete is paired with a volume, replication between the paired volumes is suspended and no data is transferred
to it or from it while in a deleted state. The remote volume that the deleted volume was paired with enters into a PausedMisconfigured state and data is no longer sent to it or from the deleted volume. Until the deleted volume is purged, it can be restored and data transfers resume. If the deleted volume gets purged from the system, the volume it was paired with enters into a StoppedMisconfigured state and the volume pairing status is removed. The purged volume becomes permanently unavailable.
:param volumeID: [required] The ID of the volume to be deleted.
:type volumeID: int
"""
self._check_connection_type("delete_volume", "Cluster")
params = {
"volumeID": volume_id,
}
# There is no adaptor.
return self.send_request(
'DeleteVolume',
DeleteVolumeResult,
params,
since=1.0
)
[docs] def delete_volumes(
self,
account_ids=OPTIONAL,
volume_access_group_ids=OPTIONAL,
volume_ids=OPTIONAL,):
"""
DeleteVolumes marks multiple (up to 500) active volumes for deletion.
Once marked, the volumes are purged (permanently deleted) after the cleanup interval elapses.
The cleanup interval can be set in the SetClusterSettings method.
For more information on using this method, see SetClusterSettings on page 1.
After making a request to delete volumes, any active iSCSI connections to the volumes are immediately terminated
and no further connections are allowed while the volumes are in this state.
A marked volume is not returned in target discovery requests.
Any snapshots of a volume that has been marked for deletion are not affected.
Snapshots are kept until the volume is purged from the system.
If a volume is marked for deletion and has a bulk volume read or bulk volume write operation in progress,
the bulk volume read or write operation is stopped.
If the volumes you delete are paired with a volume, replication between the paired volumes is suspended
and no data is transferred to them or from them while in a deleted state.
The remote volumes the deleted volumes were paired with enter into a PausedMisconfigured state
and data is no longer sent to them or from the deleted volumes.
Until the deleted volumes are purged, they can be restored and data transfers resume.
If the deleted volumes are purged from the system, the volumes they were paired with enter into a
StoppedMisconfigured state and the volume pairing status is removed.
The purged volumes become permanently unavailable.
:param accountIDs: A list of account IDs. All volumes from these accounts are deleted from the system.
:type accountIDs: int
:param volumeAccessGroupIDs: A list of volume access group IDs. All of the volumes from all of the volume access groups you specify in this list are deleted from the system.
:type volumeAccessGroupIDs: int
:param volumeIDs: The list of IDs of the volumes to delete from the system.
:type volumeIDs: int
"""
self._check_connection_type("delete_volumes", "Cluster")
params = {
}
if account_ids is not None:
params["accountIDs"] = account_ids
if volume_access_group_ids is not None:
params["volumeAccessGroupIDs"] = volume_access_group_ids
if volume_ids is not None:
params["volumeIDs"] = volume_ids
# There is no adaptor.
return self.send_request(
'DeleteVolumes',
DeleteVolumesResult,
params,
since=9.0
)
[docs] def get_default_qos(
self,):
"""
GetDefaultQoS enables you to retrieve the default QoS values for a newly created volume. """
self._check_connection_type("get_default_qos", "Cluster")
params = {
}
# There is no adaptor.
return self.send_request(
'GetDefaultQoS',
VolumeQOS,
params,
since=1.0
)
[docs] def get_volume_count(
self,):
"""
GetVolumeCount enables you to retrieve the number of volumes currently in the system. """
self._check_connection_type("get_volume_count", "Cluster")
params = {
}
# There is no adaptor.
return self.send_request(
'GetVolumeCount',
GetVolumeCountResult,
params,
since=9.0
)
[docs] def get_volume_efficiency(
self,
volume_id,):
"""
GetVolumeEfficiency enables you to retrieve information about a volume. Only the volume you give as a parameter in this API method is used to compute the capacity.
:param volumeID: [required] Specifies the volume for which capacity is computed.
:type volumeID: int
"""
self._check_connection_type("get_volume_efficiency", "Cluster")
params = {
"volumeID": volume_id,
}
# There is no adaptor.
return self.send_request(
'GetVolumeEfficiency',
GetVolumeEfficiencyResult,
params,
since=6.0
)
[docs] def get_volume_stats(
self,
volume_id,):
"""
GetVolumeStats enables you to retrieve high-level activity measurements for a single volume. Values are cumulative from the creation of the volume.
:param volumeID: [required] Specifies the volume for which statistics are gathered.
:type volumeID: int
"""
self._check_connection_type("get_volume_stats", "Cluster")
params = {
"volumeID": volume_id,
}
# There is no adaptor.
return self.send_request(
'GetVolumeStats',
GetVolumeStatsResult,
params,
since=1.0
)
[docs] def list_active_volumes(
self,
start_volume_id=OPTIONAL,
limit=OPTIONAL,
include_virtual_volumes=OPTIONAL,):
"""
ListActiveVolumes enables you to return the list of active volumes currently in the system. The list of volumes is returned sorted in
VolumeID order and can be returned in multiple parts (pages).
:param startVolumeID: Starting VolumeID to return. If no volume exists with this VolumeID, the next volume by VolumeID order is used as the start of the list. To page through the list, pass the VolumeID of the last volume in the previous response + 1.
:type startVolumeID: int
:param limit: Maximum number of Volume Info objects to return. A value of 0 (zero) returns all volumes (unlimited).
:type limit: int
:param includeVirtualVolumes: Specifies that virtual volumes are included in the response by default. To exclude virtual volumes, set to false.
:type includeVirtualVolumes: bool
"""
self._check_connection_type("list_active_volumes", "Cluster")
params = {
}
if start_volume_id is not None:
params["startVolumeID"] = start_volume_id
if limit is not None:
params["limit"] = limit
if include_virtual_volumes is not None:
if self.api_version < 9.0:
raise ApiParameterVersionError("list_active_volumes", 9.0,
[("include_virtual_volumes", include_virtual_volumes, 9.0, False)])
else:
params["includeVirtualVolumes"] = include_virtual_volumes
# There is no adaptor.
return self.send_request(
'ListActiveVolumes',
ListActiveVolumesResult,
params,
since=1.0
)
[docs] def list_bulk_volume_jobs(
self,):
"""
ListBulkVolumeJobs enables you to retrieve information about each bulk volume read or write operation that is occurring in the
system. """
self._check_connection_type("list_bulk_volume_jobs", "Cluster")
params = {
}
# There is no adaptor.
return self.send_request(
'ListBulkVolumeJobs',
ListBulkVolumeJobsResult,
params,
since=6.0
)
[docs] def list_deleted_volumes(
self,
include_virtual_volumes=OPTIONAL,):
"""
ListDeletedVolumes enables you to retrieve the list of volumes that have been marked for deletion and purged from the system.
:param includeVirtualVolumes: Specifies that virtual volumes are included in the response by default. To exclude virtual volumes, set to false.
:type includeVirtualVolumes: bool
"""
self._check_connection_type("list_deleted_volumes", "Cluster")
params = {
}
if include_virtual_volumes is not None:
if self.api_version < 9.0:
raise ApiParameterVersionError("list_deleted_volumes", 9.0,
[("include_virtual_volumes", include_virtual_volumes, 9.0, False)])
else:
params["includeVirtualVolumes"] = include_virtual_volumes
# There is no adaptor.
return self.send_request(
'ListDeletedVolumes',
ListDeletedVolumesResult,
params,
since=1.0
)
[docs] def list_volumes(
self,
start_volume_id=OPTIONAL,
limit=OPTIONAL,
volume_status=OPTIONAL,
accounts=OPTIONAL,
is_paired=OPTIONAL,
volume_ids=OPTIONAL,
volume_name=OPTIONAL,
include_virtual_volumes=OPTIONAL,):
"""
The ListVolumes method enables you to retrieve a list of volumes that are in a cluster. You can specify the volumes you want to
return in the list by using the available parameters.
:param startVolumeID: Only volumes with an ID greater than or equal to this value are returned. Mutually exclusive with the volumeIDs parameter.
:type startVolumeID: int
:param limit: Specifies the maximum number of volume results that are returned. Mutually exclusive with the volumeIDs parameter.
:type limit: int
:param volumeStatus: Only volumes with a status equal to the status value are returned. Possible values are: creating snapshotting active deleted
:type volumeStatus: str
:param accounts: Returns only the volumes owned by the accounts you specify here. Mutually exclusive with the volumeIDs parameter.
:type accounts: int
:param isPaired: Returns volumes that are paired or not paired. Possible values are: true: Returns all paired volumes. false: Returns all volumes that are not paired.
:type isPaired: bool
:param volumeIDs: A list of volume IDs. If you supply this parameter, other parameters operate only on this set of volumes. Mutually exclusive with the accounts, startVolumeID, and limit parameters.
:type volumeIDs: int
:param volumeName: Only volume object information matching the volume name is returned.
:type volumeName: str
:param includeVirtualVolumes: Specifies that virtual volumes are included in the response by default. To exclude virtual volumes, set to false.
:type includeVirtualVolumes: bool
"""
self._check_connection_type("list_volumes", "Cluster")
params = {
}
if start_volume_id is not None:
params["startVolumeID"] = start_volume_id
if limit is not None:
params["limit"] = limit
if volume_status is not None:
params["volumeStatus"] = volume_status
if accounts is not None:
params["accounts"] = accounts
if is_paired is not None:
params["isPaired"] = is_paired
if volume_ids is not None:
if self.api_version < 9.0:
raise ApiParameterVersionError("list_volumes", 9.0,
[("volume_ids", volume_ids, 9.0, False)])
else:
params["volumeIDs"] = volume_ids
if volume_name is not None:
params["volumeName"] = volume_name
if include_virtual_volumes is not None:
if self.api_version < 9.0:
raise ApiParameterVersionError("list_volumes", 9.0,
[("include_virtual_volumes", include_virtual_volumes, 9.0, False)])
else:
params["includeVirtualVolumes"] = include_virtual_volumes
# There is no adaptor.
return self.send_request(
'ListVolumes',
ListVolumesResult,
params,
since=8.0
)
[docs] def list_volumes_for_account(
self,
account_id,
start_volume_id=OPTIONAL,
limit=OPTIONAL,
include_virtual_volumes=OPTIONAL,):
"""
ListVolumesForAccount returns the list of active and (pending) deleted volumes for an account.
:param accountID: [required] Returns all volumes owned by this AccountID.
:type accountID: int
:param startVolumeID: The ID of the first volume to list. This can be useful for paging results. By default, this starts at the lowest VolumeID.
:type startVolumeID: int
:param limit: The maximum number of volumes to return from the API.
:type limit: int
:param includeVirtualVolumes: Specifies that virtual volumes are included in the response by default. To exclude virtual volumes, set to false.
:type includeVirtualVolumes: bool
"""
self._check_connection_type("list_volumes_for_account", "Cluster")
params = {
"accountID": account_id,
}
if start_volume_id is not None:
params["startVolumeID"] = start_volume_id
if limit is not None:
params["limit"] = limit
if include_virtual_volumes is not None:
if self.api_version < 9.0:
raise ApiParameterVersionError("list_volumes_for_account", 9.0,
[("include_virtual_volumes", include_virtual_volumes, 9.0, True)])
else:
params["includeVirtualVolumes"] = include_virtual_volumes
# There is no adaptor.
return self.send_request(
'ListVolumesForAccount',
ListVolumesForAccountResult,
params,
since=1.0
)
[docs] def list_volume_stats(
self,
volume_ids=OPTIONAL,):
"""
ListVolumeStats returns high-level activity measurements for a single volume, list of volumes, or all volumes (if you omit the volumeIDs parameter). Measurement values are cumulative from the creation of the volume.
:param volumeIDs: A list of volume IDs of volumes from which to retrieve activity information.
:type volumeIDs: int
"""
self._check_connection_type("list_volume_stats", "Cluster")
params = {
}
if volume_ids is not None:
params["volumeIDs"] = volume_ids
# There is no adaptor.
return self.send_request(
'ListVolumeStats',
ListVolumeStatsResult,
params,
since=7.0
)
[docs] def list_volume_stats_by_account(
self,
accounts=OPTIONAL,
include_virtual_volumes=OPTIONAL,):
"""
ListVolumeStatsByAccount returns high-level activity measurements for every account. Values are summed from all the volumes owned by the account.
:param accounts: One or more account ids by which to filter the result.
:type accounts: int
:param includeVirtualVolumes: Includes virtual volumes in the response by default. To exclude virtual volumes, set to false.
:type includeVirtualVolumes: bool
"""
self._check_connection_type("list_volume_stats_by_account", "Cluster")
params = {
}
if accounts is not None:
params["accounts"] = accounts
if include_virtual_volumes is not None:
if self.api_version < 9.0:
raise ApiParameterVersionError("list_volume_stats_by_account", 9.0,
[("include_virtual_volumes", include_virtual_volumes, 9.0, False)])
else:
params["includeVirtualVolumes"] = include_virtual_volumes
# There is no adaptor.
return self.send_request(
'ListVolumeStatsByAccount',
ListVolumeStatsByAccountResult,
params,
since=1.0
)
[docs] def list_volume_stats_by_volume(
self,
include_virtual_volumes=OPTIONAL,):
"""
ListVolumeStatsByVolume returns high-level activity measurements for every volume, by volume. Values are cumulative from the
creation of the volume.
:param includeVirtualVolumes: Specifies that virtual volumes are included in the response by default. To exclude virtual volumes, set to false.
:type includeVirtualVolumes: bool
"""
self._check_connection_type("list_volume_stats_by_volume", "Cluster")
params = {
}
if include_virtual_volumes is not None:
if self.api_version < 9.0:
raise ApiParameterVersionError("list_volume_stats_by_volume", 9.0,
[("include_virtual_volumes", include_virtual_volumes, 9.0, False)])
else:
params["includeVirtualVolumes"] = include_virtual_volumes
# There is no adaptor.
return self.send_request(
'ListVolumeStatsByVolume',
ListVolumeStatsByVolumeResult,
params,
since=1.0
)
[docs] def list_volume_stats_by_volume_access_group(
self,
volume_access_groups=OPTIONAL,
include_virtual_volumes=OPTIONAL,):
"""
ListVolumeStatsByVolumeAccessGroup enables you to get total activity measurements for all of the volumes that are a member of the
specified volume access group(s).
:param volumeAccessGroups: An array of VolumeAccessGroupIDs for which volume activity is returned. If omitted, statistics for all volume access groups are returned.
:type volumeAccessGroups: int
:param includeVirtualVolumes: Specifies that virtual volumes are included in the response by default. To exclude virtual volumes, set to false.
:type includeVirtualVolumes: bool
"""
self._check_connection_type("list_volume_stats_by_volume_access_group", "Cluster")
params = {
}
if volume_access_groups is not None:
params["volumeAccessGroups"] = volume_access_groups
if include_virtual_volumes is not None:
if self.api_version < 9.0:
raise ApiParameterVersionError("list_volume_stats_by_volume_access_group", 9.0,
[("include_virtual_volumes", include_virtual_volumes, 9.0, False)])
else:
params["includeVirtualVolumes"] = include_virtual_volumes
# There is no adaptor.
return self.send_request(
'ListVolumeStatsByVolumeAccessGroup',
ListVolumeStatsByVolumeAccessGroupResult,
params,
since=5.0
)
[docs] def modify_volume(
self,
volume_id,
account_id=OPTIONAL,
access=OPTIONAL,
qos=OPTIONAL,
total_size=OPTIONAL,
attributes=OPTIONAL,):
"""
ModifyVolume enables you to modify settings on an existing volume. You can make modifications to one volume at a time and
changes take place immediately. If you do not specify QoS values when you modify a volume, they remain the same as before the modification. You can retrieve
default QoS values for a newly created volume by running the GetDefaultQoS method.
When you need to increase the size of a volume that is being replicated, do so in the following order to prevent replication errors:
1. Increase the size of the "Replication Target" volume.
2. Increase the size of the source or "Read / Write" volume.
NetApp recommends that both the target and source volumes are the same size.
Note: If you change the "access" status to locked or target, all existing iSCSI connections are terminated.
:param volumeID: [required] VolumeID for the volume to be modified.
:type volumeID: int
:param accountID: AccountID to which the volume is reassigned. If unspecified, the previous account name is used.
:type accountID: int
:param access: Specifies the access allowed for the volume. Possible values are: readOnly: Only read operations are allowed. readWrite: Reads and writes are allowed. locked: No reads or writes are allowed. If not specified, the access value does not change. replicationTarget: Identify a volume as the target volume for a paired set of volumes. If the volume is not paired, the access status is locked. If a value is not specified, the access value does not change.
:type access: str
:param qos: New QoS settings for this volume. If not specified, the QoS settings are not changed.
:type qos: QoS
:param totalSize: New size of the volume in bytes.<PHONE_NUMBER> is equal to 1GB. Size is rounded up to the nearest 1MB. This parameter can only be used to increase the size of a volume.
:type totalSize: int
:param attributes: List of name-value pairs in JSON object format.
:type attributes: dict
"""
self._check_connection_type("modify_volume", "Cluster")
params = {
"volumeID": volume_id,
}
if account_id is not None:
params["accountID"] = account_id
if access is not None:
params["access"] = access
if qos is not None:
params["qos"] = qos
if total_size is not None:
params["totalSize"] = total_size
if attributes is not None:
params["attributes"] = attributes
# There is no adaptor.
return self.send_request(
'ModifyVolume',
ModifyVolumeResult,
params,
since=1.0
)
[docs] def modify_volumes(
self,
volume_ids,
account_id=OPTIONAL,
access=OPTIONAL,
qos=OPTIONAL,
total_size=OPTIONAL,
attributes=OPTIONAL,):
"""
ModifyVolumes allows you to configure up to 500 existing volumes at one time. Changes take place immediately.
If ModifyVolumes fails to modify any of the specified volumes, none of the specified volumes are changed.
If you do not specify QoS values when you modify volumes, the QoS values for each volume remain unchanged.
You can retrieve default QoS values for a newly created volume by running the GetDefaultQoS method.
When you need to increase the size of volumes that are being replicated, do so in the following order
to prevent replication errors:
Increase the size of the "Replication Target" volume.
Increase the size of the source or "Read / Write" volume.
Recommend that both the target and source volumes be the same size.
NOTE: If you change access status to locked or replicationTarget all existing iSCSI connections are terminated.
:param volumeIDs: [required] A list of volumeIDs for the volumes to be modified.
:type volumeIDs: int
:param accountID: AccountID to which the volume is reassigned. If none is specified, the previous account name is used.
:type accountID: int
:param access: Access allowed for the volume. Possible values:readOnly: Only read operations are allowed.readWrite: Reads and writes are allowed.locked: No reads or writes are allowed.If not specified, the access value does not change.replicationTarget: Identify a volume as the target volume for a paired set of volumes. If the volume is not paired, the access status is locked.If a value is not specified, the access value does not change.
:type access: str
:param qos: New quality of service settings for this volume.If not specified, the QoS settings are not changed.
:type qos: QoS
:param totalSize: New size of the volume in bytes.<PHONE_NUMBER> is equal to 1GB. Size is rounded up to the nearest 1MB in size. This parameter can only be used to increase the size of a volume.
:type totalSize: int
:param attributes: List of name/value pairs in JSON object format.
:type attributes: dict
"""
self._check_connection_type("modify_volumes", "Cluster")
params = {
"volumeIDs": volume_ids,
}
if account_id is not None:
params["accountID"] = account_id
if access is not None:
params["access"] = access
if qos is not None:
params["qos"] = qos
if total_size is not None:
params["totalSize"] = total_size
if attributes is not None:
params["attributes"] = attributes
# There is no adaptor.
return self.send_request(
'ModifyVolumes',
ModifyVolumesResult,
params,
since=9.0
)
[docs] def purge_deleted_volume(
self,
volume_id,):
"""
PurgeDeletedVolume immediately and permanently purges a volume that has been deleted. You must delete a volume using
DeleteVolume before it can be purged. Volumes are purged automatically after a period of time, so usage of this method is not
typically required.
:param volumeID: [required] The ID of the volume to be purged.
:type volumeID: int
"""
self._check_connection_type("purge_deleted_volume", "Cluster")
params = {
"volumeID": volume_id,
}
# There is no adaptor.
return self.send_request(
'PurgeDeletedVolume',
PurgeDeletedVolumeResult,
params,
since=1.0
)
[docs] def purge_deleted_volumes(
self,
volume_ids=OPTIONAL,
account_ids=OPTIONAL,
volume_access_group_ids=OPTIONAL,):
"""
PurgeDeletedVolumes immediately and permanently purges volumes that have been deleted.
You can use this method to purge up to 500 volumes at one time.
You must delete volumes using DeleteVolumes before they can be purged.
Volumes are purged by the system automatically after a period of time, so usage of this method is not typically required.
:param volumeIDs: A list of volumeIDs of volumes to be purged from the system.
:type volumeIDs: int
:param accountIDs: A list of accountIDs. All of the volumes from all of the specified accounts are purged from the system.
:type accountIDs: int
:param volumeAccessGroupIDs: A list of volumeAccessGroupIDs. All of the volumes from all of the specified Volume Access Groups are purged from the system.
:type volumeAccessGroupIDs: int
"""
self._check_connection_type("purge_deleted_volumes", "Cluster")
params = {
}
if volume_ids is not None:
params["volumeIDs"] = volume_ids
if account_ids is not None:
params["accountIDs"] = account_ids
if volume_access_group_ids is not None:
params["volumeAccessGroupIDs"] = volume_access_group_ids
# There is no adaptor.
return self.send_request(
'PurgeDeletedVolumes',
PurgeDeletedVolumesResult,
params,
since=9.0
)
[docs] def remove_volumes_from_volume_access_group(
self,
volume_access_group_id,
volumes,):
"""
The RemoveVolumeFromVolumeAccessGroup method enables you to remove volumes from a volume access group.
:param volumeAccessGroupID: [required] The ID of the volume access group to remove volumes from.
:type volumeAccessGroupID: int
:param volumes: [required] The ID of the volume access group to remove volumes from.
:type volumes: int
"""
self._check_connection_type("remove_volumes_from_volume_access_group", "Cluster")
params = {
"volumeAccessGroupID": volume_access_group_id,
"volumes": volumes,
}
# There is no adaptor.
return self.send_request(
'RemoveVolumesFromVolumeAccessGroup',
ModifyVolumeAccessGroupResult,
params,
since=5.0
)
[docs] def restore_deleted_volume(
self,
volume_id,):
"""
RestoreDeletedVolume marks a deleted volume as active again. This action makes the volume immediately available for iSCSI connection.
:param volumeID: [required] VolumeID of the deleted volume to be restored.
:type volumeID: int
"""
self._check_connection_type("restore_deleted_volume", "Cluster")
params = {
"volumeID": volume_id,
}
# There is no adaptor.
return self.send_request(
'RestoreDeletedVolume',
RestoreDeletedVolumeResult,
params,
since=1.0
)
[docs] def set_default_qos(
self,
min_iops=OPTIONAL,
max_iops=OPTIONAL,
burst_iops=OPTIONAL,):
"""
SetDefaultQoS enables you to configure the default Quality of Service (QoS) values (measured in inputs and outputs per second, or
IOPS) for a volume. For more information about QoS in a SolidFire cluster, see the User Guide.
:param minIOPS: The minimum number of sustained IOPS provided by the cluster to a volume.
:type minIOPS: int
:param maxIOPS: The maximum number of sustained IOPS provided by the cluster to a volume.
:type maxIOPS: int
:param burstIOPS: The maximum number of IOPS allowed in a short burst scenario.
:type burstIOPS: int
"""
self._check_connection_type("set_default_qos", "Cluster")
params = {
}
if min_iops is not None:
params["minIOPS"] = min_iops
if max_iops is not None:
params["maxIOPS"] = max_iops
if burst_iops is not None:
params["burstIOPS"] = burst_iops
# There is no adaptor.
return self.send_request(
'SetDefaultQoS',
SetDefaultQoSResult,
params,
since=9.0
)
[docs] def start_bulk_volume_read(
self,
volume_id,
format,
snapshot_id=OPTIONAL,
script=OPTIONAL,
script_parameters=OPTIONAL,
attributes=OPTIONAL,):
"""
StartBulkVolumeRead enables you to initialize a bulk volume read session on a specified volume. Only two bulk volume processes
can run simultaneously on a volume. When you initialize the session, data is read from a SolidFire storage volume for the purposes
of storing the data on an external backup source. The external data is accessed by a web server running on an SF-series node.
Communications and server interaction information for external data access is passed by a script running on the storage system.
At the start of a bulk volume read operation, a snapshot of the volume is made and the snapshot is deleted when the read is complete. You can also read a snapshot of the volume by entering the ID of the snapshot as a parameter. When you read a
previous snapshot, the system does not create a new snapshot of the volume or delete the previous snapshot when the
read completes.
Note: This process creates a new snapshot if the ID of an existing snapshot is not provided. Snapshots can be created if cluster fullness is at stage 2 or 3. Snapshots are not created when cluster fullness is at stage 4 or 5.
:param volumeID: [required] The ID of the volume to be read.
:type volumeID: int
:param format: [required] The format of the volume data. It can be either of the following formats: uncompressed: Every byte of the volume is returned without any compression. native: Opaque data is returned that is smaller and more efficiently stored and written on a subsequent bulk volume write.
:type format: str
:param snapshotID: The ID of a previously created snapshot used for bulk volume reads. If no ID is entered, a snapshot of the current active volume image is made.
:type snapshotID: int
:param script: The executable name of a script. If unspecified, the key and URL is necessary to access SF-series nodes. The script is run on the primary node and the key and URL is returned to the script so the local web server can be contacted.
:type script: str
:param scriptParameters: JSON parameters to pass to the script.
:type scriptParameters: dict
:param attributes: JSON attributes for the bulk volume job.
:type attributes: dict
"""
self._check_connection_type("start_bulk_volume_read", "Cluster")
params = {
"volumeID": volume_id,
"format": format,
}
if snapshot_id is not None:
params["snapshotID"] = snapshot_id
if script is not None:
params["script"] = script
if script_parameters is not None:
params["scriptParameters"] = script_parameters
if attributes is not None:
params["attributes"] = attributes
# There is no adaptor.
return self.send_request(
'StartBulkVolumeRead',
StartBulkVolumeReadResult,
params,
since=6.0
)
[docs] def start_bulk_volume_write(
self,
volume_id,
format,
script=OPTIONAL,
script_parameters=OPTIONAL,
attributes=OPTIONAL,):
"""
StartBulkVolumeWrite enables you to initialize a bulk volume write session on a specified volume. Only two bulk volume processes can run simultaneously on a volume. When you initialize the write session, data is written to a SolidFire storage volume from an external backup source. The external data is accessed by a web server running on an SF-series node. Communications and server
interaction information for external data access is passed by a script running on the storage system.
:param volumeID: [required] The ID of the volume to be written to.
:type volumeID: int
:param format: [required] The format of the volume data. It can be either of the following formats: uncompressed: Every byte of the volume is returned without any compression. native: Opaque data is returned that is smaller and more efficiently stored and written on a subsequent bulk volume write.
:type format: str
:param script: The executable name of a script. If unspecified, the key and URL are necessary to access SF-series nodes. The script runs on the primary node and the key and URL is returned to the script, so the local web server can be contacted.
:type script: str
:param scriptParameters: JSON parameters to pass to the script.
:type scriptParameters: dict
:param attributes: JSON attributes for the bulk volume job.
:type attributes: dict
"""
self._check_connection_type("start_bulk_volume_write", "Cluster")
params = {
"volumeID": volume_id,
"format": format,
}
if script is not None:
params["script"] = script
if script_parameters is not None:
params["scriptParameters"] = script_parameters
if attributes is not None:
params["attributes"] = attributes
# There is no adaptor.
return self.send_request(
'StartBulkVolumeWrite',
StartBulkVolumeWriteResult,
params,
since=6.0
)
[docs] def update_bulk_volume_status(
self,
key,
status,
percent_complete=OPTIONAL,
message=OPTIONAL,
attributes=OPTIONAL,):
"""
You can use UpdateBulkVolumeStatus in a script to update the status of a bulk volume job that you started with the
StartBulkVolumeRead or StartBulkVolumeWrite methods.
:param key: [required] The key assigned during initialization of a StartBulkVolumeRead or StartBulkVolumeWrite session.
:type key: str
:param status: [required] The status of the given bulk volume job. The system sets the status. Possible values are: running: Jobs that are still active. complete: Jobs that are done. failed: Jobs that failed.
:type status: str
:param percentComplete: The completed progress of the bulk volume job as a percentage value.
:type percentComplete: str
:param message: The message returned indicating the status of the bulk volume job after the job is complete.
:type message: str
:param attributes: JSON attributes; updates what is on the bulk volume job.
:type attributes: dict
"""
self._check_connection_type("update_bulk_volume_status", "Cluster")
params = {
"key": key,
"status": status,
}
if percent_complete is not None:
params["percentComplete"] = percent_complete
if message is not None:
params["message"] = message
if attributes is not None:
params["attributes"] = attributes
# There is no adaptor.
return self.send_request(
'UpdateBulkVolumeStatus',
UpdateBulkVolumeStatusResult,
params,
since=6.0
)
[docs] def create_volume_access_group(
self,
name,
initiators=OPTIONAL,
volumes=OPTIONAL,
virtual_network_id=OPTIONAL,
virtual_network_tags=OPTIONAL,
attributes=OPTIONAL,):
"""
You can use CreateVolumeAccessGroup to create a new volume access group. When you create the volume access group, you need to give it a name, and you can optionally enter initiators and volumes. After you create the group, you can add volumes and initiator IQNs. Any initiator IQN that you add to the volume access group is able to access any volume in the group without CHAP authentication.
:param name: [required] The name for this volume access group. Not required to be unique, but recommended.
:type name: str
:param initiators: List of initiators to include in the volume access group. If unspecified, the access group's configured initiators are not modified.
:type initiators: str
:param volumes: List of volumes to initially include in the volume access group. If unspecified, the access group's volumes are not modified.
:type volumes: int
:param virtualNetworkID: The ID of the SolidFire virtual network to associate the volume access group with.
:type virtualNetworkID: int
:param virtualNetworkTags: The ID of the SolidFire virtual network to associate the volume access group with.
:type virtualNetworkTags: int
:param attributes: List of name-value pairs in JSON object format.
:type attributes: dict
"""
self._check_connection_type("create_volume_access_group", "Cluster")
params = {
"name": name,
}
if initiators is not None:
params["initiators"] = initiators
if volumes is not None:
params["volumes"] = volumes
if virtual_network_id is not None:
if self.api_version < 8.0:
raise ApiParameterVersionError("create_volume_access_group", 8.0,
[("virtual_network_id", virtual_network_id, 8.0, False)])
else:
params["virtualNetworkID"] = virtual_network_id
if virtual_network_tags is not None:
if self.api_version < 8.0:
raise ApiParameterVersionError("create_volume_access_group", 8.0,
[("virtual_network_tags", virtual_network_tags, 8.0, False)])
else:
params["virtualNetworkTags"] = virtual_network_tags
if attributes is not None:
params["attributes"] = attributes
# There is no adaptor.
return self.send_request(
'CreateVolumeAccessGroup',
CreateVolumeAccessGroupResult,
params,
since=5.0
)
[docs] def delete_volume_access_group(
self,
volume_access_group_id,):
"""
DeleteVolumeAccessGroup enables you to delete a
volume access group.
:param volumeAccessGroupID: [required] The ID of the volume access group to be deleted.
:type volumeAccessGroupID: int
"""
self._check_connection_type("delete_volume_access_group", "Cluster")
params = {
"volumeAccessGroupID": volume_access_group_id,
}
# There is no adaptor.
return self.send_request(
'DeleteVolumeAccessGroup',
DeleteVolumeAccessGroupResult,
params,
since=5.0
)
[docs] def get_volume_access_group_efficiency(
self,
volume_access_group_id,):
"""
GetVolumeAccessGroupEfficiency enables you to
retrieve efficiency information about a volume access
group. Only the volume access group you provide as the
parameter in this API method is used to compute the
capacity.
:param volumeAccessGroupID: [required] The volume access group for which capacity is computed.
:type volumeAccessGroupID: int
"""
self._check_connection_type("get_volume_access_group_efficiency", "Cluster")
params = {
"volumeAccessGroupID": volume_access_group_id,
}
# There is no adaptor.
return self.send_request(
'GetVolumeAccessGroupEfficiency',
GetEfficiencyResult,
params,
since=6.0
)
[docs] def get_volume_access_group_lun_assignments(
self,
volume_access_group_id,):
"""
The GetVolumeAccessGroupLunAssignments
method enables you to retrieve details on LUN mappings
of a specified volume access group.
:param volumeAccessGroupID: [required] The unique volume access group ID used to return information.
:type volumeAccessGroupID: int
"""
self._check_connection_type("get_volume_access_group_lun_assignments", "Cluster")
params = {
"volumeAccessGroupID": volume_access_group_id,
}
# There is no adaptor.
return self.send_request(
'GetVolumeAccessGroupLunAssignments',
GetVolumeAccessGroupLunAssignmentsResult,
params,
since=7.0
)
[docs] def list_volume_access_groups(
self,
start_volume_access_group_id=OPTIONAL,
limit=OPTIONAL,
volume_access_groups=OPTIONAL,):
"""
ListVolumeAccessGroups enables you to return
information about the volume access groups that are
currently in the system.
:param startVolumeAccessGroupID: The volume access group ID at which to begin the listing. If unspecified, there is no lower limit (implicitly 0).
:type startVolumeAccessGroupID: int
:param limit: The maximum number of results to return. This can be useful for paging.
:type limit: int
:param volumeAccessGroups: The list of ids of the volume access groups you wish to list
:type volumeAccessGroups: int
"""
self._check_connection_type("list_volume_access_groups", "Cluster")
params = {
}
if start_volume_access_group_id is not None:
params["startVolumeAccessGroupID"] = start_volume_access_group_id
if limit is not None:
params["limit"] = limit
if volume_access_groups is not None:
params["volumeAccessGroups"] = volume_access_groups
# There is no adaptor.
return self.send_request(
'ListVolumeAccessGroups',
ListVolumeAccessGroupsResult,
params,
since=5.0
)
[docs] def modify_volume_access_group(
self,
volume_access_group_id,
virtual_network_id=OPTIONAL,
virtual_network_tags=OPTIONAL,
name=OPTIONAL,
initiators=OPTIONAL,
volumes=OPTIONAL,
delete_orphan_initiators=OPTIONAL,
attributes=OPTIONAL,):
"""
You can use ModifyVolumeAccessGroup to update initiators and add or remove volumes from a volume access group. If a specified initiator or volume is a duplicate of what currently exists, the volume access group is left as-is. If you do not specify a value for volumes or initiators, the current list of initiators and volumes is not changed.
:param volumeAccessGroupID: [required] The ID of the volume access group to modify.
:type volumeAccessGroupID: int
:param virtualNetworkID: The ID of the SolidFire virtual network to associate the volume access group with.
:type virtualNetworkID: int
:param virtualNetworkTags: The ID of the SolidFire virtual network to associate the volume access group with.
:type virtualNetworkTags: int
:param name: The new name for this volume access group. Not required to be unique, but recommended.
:type name: str
:param initiators: List of initiators to include in the volume access group. If unspecified, the access group's configured initiators are not modified.
:type initiators: str
:param volumes: List of volumes to initially include in the volume access group. If unspecified, the access group's volumes are not modified.
:type volumes: int
:param deleteOrphanInitiators: true: Delete initiator objects after they are removed from a volume access group. false: Do not delete initiator objects after they are removed from a volume access group.
:type deleteOrphanInitiators: bool
:param attributes: List of name-value pairs in JSON object format.
:type attributes: dict
"""
self._check_connection_type("modify_volume_access_group", "Cluster")
params = {
"volumeAccessGroupID": volume_access_group_id,
}
if virtual_network_id is not None:
if self.api_version < 8.0:
raise ApiParameterVersionError("modify_volume_access_group", 8.0,
[("virtual_network_id", virtual_network_id, 8.0, False)])
else:
params["virtualNetworkID"] = virtual_network_id
if virtual_network_tags is not None:
if self.api_version < 8.0:
raise ApiParameterVersionError("modify_volume_access_group", 8.0,
[("virtual_network_tags", virtual_network_tags, 8.0, False)])
else:
params["virtualNetworkTags"] = virtual_network_tags
if name is not None:
params["name"] = name
if initiators is not None:
params["initiators"] = initiators
if volumes is not None:
params["volumes"] = volumes
if delete_orphan_initiators is not None:
if self.api_version < 9.0:
raise ApiParameterVersionError("modify_volume_access_group", 9.0,
[("delete_orphan_initiators", delete_orphan_initiators, 9.0, False)])
else:
params["deleteOrphanInitiators"] = delete_orphan_initiators
if attributes is not None:
params["attributes"] = attributes
# There is no adaptor.
return self.send_request(
'ModifyVolumeAccessGroup',
ModifyVolumeAccessGroupResult,
params,
since=5.0
)
[docs] def modify_volume_access_group_lun_assignments(
self,
volume_access_group_id,
lun_assignments,):
"""
The ModifyVolumeAccessGroupLunAssignments
method enables you to define custom LUN assignments
for specific volumes. This method changes only LUN
values set on the lunAssignments parameter in the
volume access group. All other LUN assignments remain
unchanged. LUN assignment values must be unique for volumes in a volume access group. You cannot define duplicate LUN values within a volume access group. However, you can use the same LUN values again in different volume access groups.
Note: Correct LUN values are 0 through 16383. The system generates an exception if you pass a LUN value outside of this range. None of the specified LUN assignments are modified if there is an exception.
Caution: If you change a LUN assignment for a volume with active I/O, the I/O can be disrupted. You might need to change the server configuration before changing volume LUN assignments.
:param volumeAccessGroupID: [required] The ID of the volume access group for which the LUN assignments will be modified.
:type volumeAccessGroupID: int
:param lunAssignments: [required] The volume IDs with new assigned LUN values.
:type lunAssignments: LunAssignment
"""
self._check_connection_type("modify_volume_access_group_lun_assignments", "Cluster")
params = {
"volumeAccessGroupID": volume_access_group_id,
"lunAssignments": lun_assignments,
}
# There is no adaptor.
return self.send_request(
'ModifyVolumeAccessGroupLunAssignments',
ModifyVolumeAccessGroupLunAssignmentsResult,
params,
since=7.0
)


Neuroplasticity is the science of the brain adapting to changes and new information over time. The name comes from the idea that our brains are 'plastic' mouldable objects, that can grow and create new pathways for holding information.
It's beneficial to know, because it proves that no person cannot learn something they want to. The science behind it is that as you try and learn new information; that you may feel is out of your realm of expertise and completely above you; is in fact within grasp of you being able to learn it.
It proves that because a person may not be great with maths, they still have an equal opportunity to become great at it. Improvement over time builds new pathways to retain new information, which get stronger and larger as you work on it.
Basically, the brain is in fact a muscle - and how you work that muscle out is entirely up to you - but it's extremely important to know that you CAN in fact learn whatever you set out to. Dedication and training is key to growth - this all builds on your neuroplasticity, as it moulds and adapts.
If you want to know more, I highly recommend having a read through of this link: Neuroplasticity
The growth mindset, is different to neuroplasticity in the sense that it's more of an emotional and environmental trait. It's still about you - but maybe not as much of a scientific form.
The Growth Mindset is relevant because it's a sympathetic, helpful trait to have or understand. The idea behind the growth mindset is that essentially you put a positive spin on actions of yourself and those around you.
For example, look at a grading system. Whether that's in school, high school, university etc. You've got a threshold for all testing, and it's usually a pass/fail system at it's core.
This word 'fail', has such a negative connotation and effect on people. It doesn't make you feel good - in fact, in every case would make you feel worse.
In the growth mindset though, if you were to replace the word 'fail' with a 'not yet' for example; this makes the student or person - not feel like they gave it their all and they didn't get the result they were after. It implies that with more practice, more study, more time - that it's something that's still achievable. The example of using the word 'not yet' has been tested in schools, and the outcome for the students always ends up higher than the original pass/fail lingo.
I think if everyone adopts this mindset, it not only helps you be more sympathetic and relateable - it also makes you more supportive for those around you and yourself.
Going down the rabbit hole of looking into a growth mindset has been a real eye opener to how we can systematically target things in our community, and provide a more supportive and open platform for everyone - and I for one, will be opting for this in the future.
You can watch a really great TED talk on it here: The Growth Mindset


Filming and Photography
Metro Transit Usage and Partnership Proposals:
Filming and Photography
Individuals seeking to film or take photographs on Metro Transit property and vehicles are encouraged to work with Metro Transit to ensure all activities are done safely and responsibly. The following information is needed to respond to film and photo requests. Please respond in as much detail as possible. A two-week advance notice is preferred.
Please include preferred date(s) and time(s). If your request involves an in-service bus or train, please indicate the boarding location and specific boarding time (stop numbers and schedules are available at metrotransit.org). Please consider providing at least one alternative date/time.
Guidelines
Metro Transit will provide guidance to ensure filming and photography is done in accordance with Metro Transit policies. General guidelines are as follows:
- Cast and crew must follow transit safety guidelines, including special guidance provided by Metro Transit.
- Cast and crew members must have a valid fare while on transit property unless otherwise allowed by Metro Transit.
- Cast and crew members must have valid and visible identification while on transit property.
- Metro Transit employees and customers not involved in the photo or film project should not appear in any photo or video without express written consent.
- All third-party advertising, including exterior ads on buses or trains, must be excluded from any photo or video.
- A designated contact must be identified and available by phone while photography and/or filming occur.
Questions can be directed to:
Drew Kerr, Public Relations Specialist
<EMAIL_ADDRESS>Office:<PHONE_NUMBER>
Cell:<PHONE_NUMBER>
Fax:<PHONE_NUMBER>


We welcome businesses to come serve at Mercy Warehouse. Sorting, organizing, moving, hanging, smiling..If you wish to volunteer at the Mercy Warehouse, we've got a job or you! There is no group too small or too large to serve. Volunteering at the Mercy Warehouse is an effective way to provide employees with meaningful opportunities, engage and develop skills away from the office, break out of 'comfort zones', and boost public image.
"92% of surveyed corporate human resources executives agree that contributing business skills and expertise to a nonprofit can be an effective way to emprove employees' leadership and broader professional skill sets."
- Deloitte Volunteer IMPACT Survey
"Look. See. Do something about it."
One of our main functions at the Mercy Warehouse is the distribute food to those in need, at any stage of life. You are always welcome to visit us if you are in need. Food is typically distributed about an hour after sign-ins begin. Sign-ins close about 30 minutes after the sign-in opening


KzmStatBar
Date: 28.Dec.95
I wrote this applet for testing purpose, in order to give the opportunity
to have a simple and easy to use statistic. There is a file, containing
values, labels and colors of all the bars, and then display them basing
on the dimension of the applet. Actually this is a "beta" release, i'll
try to implement as soon as possible.
PARAMETERS
- StatFile: (String, default=stat.txt)
- This is the name of the file contaning the informations about the chart.
Here is an example of the file:
10,BAR 1,red
13,BAR 2,white
15,BAR 3,green
12,BAR 4,blue
18,BAR 5,cyan
11,BAR 6,yellow
- Copyright: (String)
- Ok, this is a copyright line. Please don't change it. This applet
is freeware, so the only cost is to leave this copyright parameter.
DOWNLOAD "KzmStatBar.zip"


This little codepen project is meant to remind myself of how redux works. It uses the analogy of an insurance company to enhance the clarity of the different functionalities and steps involved in redux. The idea is from a youtube video but anyway I copied it here. Open the console to confirm it is working.
Use store.dipatch('some_form_name'('variable(s)')) then console.log(store.getState()) to confirm the object is being updated.
The general analogy in regards to the insurance company is:
Action Creator = Submitting a form
Action = Form Types
Dispatch = Form Receiver sends the form to the different departments
Reducers = Departments
State = Outsourced history of all the forms that have ever been processed, visible to all
Someone submits an insurance form to the company. The form receiver takes
the form and sends it to all the departments. The departments look at the
type of form and act accordingly, updating the necessary information.
In our case the accounting department will add or subtract money to
the bank depending on if a person is joining a policy or a claim is being
made. For the claim department they will add a name to their list of claims
everytime someone makes a claim. Finally, for the policy department they
will add or remove names to the list of policy holders based on if someone
is joining or canceling a subscription to a policy. Note multiple
departments can be working simultaneously after receiving the same form, so
their is lots of overlap. To account for that all departments are sent a copy
of the form each time. The departments update their data by calling on
the centralized data held outside the departments, asking for the newest copy
then they return the updated version. By having the data outsourced the CEO
and other teams can access the data and form a picture of the company more
easily.
When dispatching an action (form) the combineReducers is the redux function used to link all reducers (send the action to each of the departments).
The store is another redux function that represents the whole state-tree (the outsourced data the departments access). When store.dispatch(...), is called the state is
open to being updated by the reducers invoked with the action.
If you want a more thorough revision than the brief overview above. The 47 minute full video is here.


High Low Number Guessing Game
10
100
1000
Start Game
Guess a number between 1 and
Check your guesses
player 1 was
high
player 2 was
high
player 3 was
high
player 4 was
high
Abandon Game
Restart Game


equals()
calls on enum constants.
Such calls can be replaced by an identity comparison (==
) because two
enum constants are equal only when they have the same identity.
A quick-fix is available to change the call to a comparison.
Example:
boolean foo(MyEnum value) {
return value.equals(MyEnum.FOO);
}
After the quick-fix is applied:
boolean foo(MyEnum value) {
return value == MyEnum.FOO;
}


| fkGraphics reference pages | |
slice2d
synopsis
get a 2d slice from a n-dimensional matrix
syntax
slice=SLICE2D(m)
slice=SLICE2D(m,options)
description
slice=SLICE2D(m) returns a slice of matrix m defined in the first two
dimensions and index=1 in all other dimensions.
slice=SLICE2D(m,options) where options is a struct with the following
fields:
- x
- dimension of m that defines the x-dimension of the slice
- y
- dimension of m that defines the y-dimension of the slice
- z
- dimension of m that defines the rgb dimension of the slice (z=0 for a non-color slice)
- slice_index
- for each dimension of m the index for the slice. In case z>0, this determines the red color component.
- slice_index2
- for each dimension of m the index of the green color component (only used if z>0).
- slice_index3
- for each dimension of m the index of the blue color component (only used if z>0).
- slice_method
- one of 'slice', 'sum', 'max'. For 'sum' and 'max' the slice is the sum/max of along all dimensions but the x and y dimensions. The rgb dimension of the slice is only supported for the 'slice' method.
| line2patch | Toolbox page | demo_cursor |


Mitsubishi Xpander Cross revealed
by Akbar MerchantRugged version of the Mitsubishi Xpander MPV will go on sale in Indonesia first; India launch unconfirmed.
Mitsubishi has taken the wraps off the Xpander Cross, which is essentially a rugged alternative to the standard Xpander MPV. The model will first go on sale in Indonesia and then will be introduced in other ASEAN markets.
The Xpander Cross gets the same body panels as the Xpander MPV but with a number of tweaks to distinguish itself from the standard model. What helps differentiate it from the standard Xpander is that it gets a new front bumper with a skid plate to give it more road presence. It also gets a new grille finished in black rather than chrome. Also, the rugged variant gets new LED headlamps and LED foglamps. The Xpander Cross gets black body cladding all around, restyled 17-inch wheels with larger profile tyres, new roof rails and a rear new bumper with a faux skid plate.
On the inside, the Cross gets an all-black interior with higher variants sporting a dual-tone black and red theme.
In addition to these cosmetic changes, the Xpander Cross also gets an additional 25mm of ground clearance over the standard model, at 225mm. It is also 50mm wider.
Under the hood, the Xpander gets the same 1.5-litre petrol engine as the Xpander and will be sold as a front-wheel-drive only. The model will be built at Mitsubishi’s Indonesia plant and will be exported to other ASEAN markets later.
As far as India is concerned, Mitsubishi has no plans to bring the Xpander to our shores anytime soon. The carmaker currently has the Outlander on sale in our market. Read more about it here.


In honor of the football season beginning on the 4th, enjoy this picture of our beautiful stadium. Click on it to open it in a new browser.
Image Source: https://www.indystar.com/story/sports/college/indiana/2019/05/29/iu-football-memorial-stadium-feature-tiered-pricing-seating-fred-glass/1274024001/


Move
Description:
Move coin to other chain,need wait 10min after BlockID not equal 0.
Source Chain:
*
Target Chain:
*
Amount
*
Energy
Submit


A B C D E G H I L M N O P R S T U V W
All Classes All Packages
All Classes All Packages
All Classes All Packages
A
- AbstractPickupPointFrame - Class in PickupPointSystem.GraphicalInterface
- AbstractPickupPointFrame() - Constructor for class PickupPointSystem.GraphicalInterface.AbstractPickupPointFrame
-
The constructor.
- addDays(Date, int) - Method in class DeliveryManSystem.DateHandler
-
This method adds the number of days passed as an argument to the date.
- addDays(Date, int) - Method in class PickupPointSystem.DateHandler
-
This method adds the number of days passed as an argument to the date.
- addDeliverymanPackages() - Method in class PickupPointSystem.LoginDelMan
-
This method adds the DeliveryMan packages that is authenticated.
- addObserver(ObserverLogin) - Method in class DeliveryManSystem.GraphicalInterfaceClientSystem.LoginPanel
- addObserver(ObserverCredentials) - Method in class PickupPointSystem.CredentialsReceiver
-
This method adds an ObserverCredentials to the observers ArrayList
- addPackage(PackageTable) - Method in class PickupPointSystem.LockerSystem.BoxType.Box
-
This method adds the pack inside the box
- addPackage(PackageTable) - Method in class PickupPointSystem.PickupPoint
-
This method adds the package to the smaller box that can contain it, adds the box to the available boxes by setting the password, updates the database delivery and sends the delivery mail.
- addPackageAndTestWrongCode() - Method in class PickupPointSystem.PickupPointTest
-
This method adds a package, then checks that inputting a wrong code doesn't stop or impede the server
- addTestPackages() - Method in class PickupPointSystem.DatabaseSystem.Mappers.MainServerConnector
-
This method adds test packages to the database.
- afterTest() - Static method in class ServerAndDatabase.MainServerTest
-
After carrying out all the tests, this method makes sure the connection will be closed correctly
- AlertLabel - Class in DeliveryManSystem.GraphicalInterfaceClientSystem
-
This class is the label that will contain warning and success messages for the delivery man
- AlertLabel - Class in PickupPointSystem.GraphicalInterface
-
This class is the label that contains the successfull and failed authentication strings
- AlertLabel() - Constructor for class DeliveryManSystem.GraphicalInterfaceClientSystem.AlertLabel
-
The constructor.
- AlertLabel(String, boolean) - Constructor for class DeliveryManSystem.GraphicalInterfaceClientSystem.AlertLabel
-
The constructor.
- AlertLabel(String, String) - Constructor for class PickupPointSystem.GraphicalInterface.AlertLabel
-
The constructor.
All Classes All Packages


Coors Brewing Company
Main Navigation
Home
About us
Product
Advertisements
Contact us
About Us
Our Team
OUR TEAM
History
HISTORY
Community


When you work with us, you are part of a team of commited collaborators. All aspects of our software development are intergrated, interactive
and agile.
Our approach unifies design, development and project management to create exceptional products.
We start every project by understanding your business goals, the user's needs and the product requirements.
Then we help translate them into effective and elegant solutions.
Before we sign a contract or write a line of code our team will spend the necessary time needed to understand your product vission.
The outcome of this scoping session is proposal or high-level statement of work.
Based on your requirements, we can provide a complete offering or just the pieces you need.
Our design practice offers a full range of services including brand strategy, interaction and visual design and user experience testing.
Throughout your project, our designers create and implement visual design and workflows, solicit user feedback and work with you to make sure what gets built is what is needed.
DESIGN
All engineers are fluent in the latest enterprise, mobile and web development technologies.
They collaborate with your team to write, and improve code on a daily basis, using proven practices such as test-driven development and pair programming.
DEVELOPMENT
All engineers are fluent in the latest enterprise, mobile and web development technologies.
They collaborate with your team to write, and improve code on a daily basis, using proven practices such as test-driven development and pair programming.
PRODUCT MANAGEMENT
Black Studio
Pyramids
Ontario Security
Jim Carry
Have a nice Day
Calculator
Burned
Giraffe Restaurant


|
IVT
|
Data structure for the representation of a 2D straight line. More...
#include <Structs.h>
Public Member Functions | |
| StraightLine2d () | |
| StraightLine2d (const Vec2d &point1, const Vec2d &point2) | |
| StraightLine2d (float angle, float c) | |
| StraightLine2d (const PointPair2d &pointPair) | |
Public Attributes | |
| Vec2d | point |
| An aribtrary point belonging to the straight line. More... | |
| Vec2d | directionVector |
| The normalized direction vector of the straight line. More... | |
| Vec2d | normalVector |
| The normalized normal vector of the straight line. More... | |
| float | c |
| The negative scalar product of normalVector and point. More... | |
Data structure for the representation of a 2D straight line.
The function PrimitivesDrawer::DrawLine draws a straight line, given its specification in this struct. Other functions (e.g. detectors) can use this struct as well.
The two independent straight line equations are:
where any satisfying one of these equations belongs to the straight line, = point, = directionVector, and = normalVector.
|
inline |
|
inline |
| float StraightLine2d::c |
| Vec2d StraightLine2d::directionVector |
| Vec2d StraightLine2d::normalVector |
| Vec2d StraightLine2d::point |


Figure If supported,this image below is loaded from IndexedDB A mighty big elephant,and mighty close too!


---
title: "RON HEADINGS ENDURING FOREST EXHIBIT"
date: "2000-01-01 18:05:25 -06:00"
categories:
- exhibit
subtitle: A Celebration of Trees in Wire
layout: "free-events"
event-image: "ron-headings-wiretree-exhibit.jpg"
event-dates: "MAY 25 - JUNE 17, 2018"
event-location: "Red Butte Garden Visitor Center"
button-type: "register"
tickets-link: ""
registration-info: "Questions?
Please call<PHONE_NUMBER>"
instructor-info: "N/A"
member-cost: "Free"
public-cost: "Garden Admission"
event-notes: "Artist Reception May 26 @ 2-4PM"
tickets-button: "hide"
refund-policy: "hide"
published: false
---
Meet the Artist Reception
Saturday, May 26 from 2-4PM
Ron Headings, 58, began creating wire trees as a teenager in Kansas. Inspired by his love of horticulture and the coaching of a local horticulture extension agent, Ron has refined his work with wire and rock over the years.
Trees are like people, the forest like humanity. They come in an infinate number of colors, shapes, and sizes - each one is beautiful in it's own way. The trees, like people, are shaped by their genetic structure and the environment in which they live.
Trees are created as a certain species with a variety of characteristics. Then they are changed by the locations in which they live, the amount of water and nutrients they receive, and the impact of wind and weather.
For more, please visit: www.HeadingsArts.com


--- ---
This document describes minimal steps necessary to create a data-aware browsing component that displays data for a single field. The example component is a TPanel descendant with DataSource and DataField properties similar to the TDBText component. "Making a Control Data-Aware" in the Component Writer's Guide in the Delphi help file for further examples.
Create or derive a component that allows the display, but not the entry of data. For instance, you could use a TMemo with ReadOnly set to true. In the example outlined in this document, we'll use a TCustomPanel. This will allow display, but not data entry.
Create or derive a component that allows the display, but not the entry of data. We'll be using a TCustomPanel as a starting point for this example.
In Delphi, choose the appropriate menu option to create a new component (this will vary between editions of Delphi), and specify TDBPanel as the class name, and TCustomPanel as the ancestor type. You may specify any palette page.
Add DB and DBTables to your uses clause.
Add a data-link object to the component's private section. This example will display data for a single field, so we will use a TFieldDataLink to provide the connection between our new component and a data-source. Name the new data-link object FDataLink. Example:
private FDataLink: TFieldDataLink;
Add DataField and DataSource properties to the component. We will add supporting code for the get and set methods in following steps. Note that our new component will have DataField and DataSource properties and FDataLink will also have its own DataField and Datasource properties. Example:
published property DataField: string read GetDataField write SetDataField; property DataSource: TDataSource read GetDataSource write SetDataSource;
Add private methods to get and set the DataField and DataSource property values to and from the DataField and DataSource for FDataLink. Example:
... private FDataLink: TFieldDataLink; function GetDataField: String; function GetDataSource: TDataSource; procedure SetDataField(Const Value: string); procedure SetDataSource(Value: TDataSource); ... implementation function TDBPanel.GetDataField: String; begin Result := FDataLink.FieldName; end; function TDBPanel.GetDataSource: TDataSource; begin Result := FDataLink.DataSource; end; procedure TDBPanel.SetDataField(Const Value: string); begin FDataLink.FieldName := Value; end; procedure TDBPanel.SetDataSource(Value: TDataSource); begin FDataLink.DataSource := Value; end;
Add a private DataChange method to be assigned to the data-link's OnDataChange event. In the DataChange method add code to display actual database field data provided by the data-link object. In this example, we assign FDataLink's field value to the panel's caption. Example:
... private procedure DataChange(Sender: TObject); ... implementation procedure TDBPanel.DataChange(Sender: TObject); begin if FDataLink.Field = nil then Caption := ''; else Caption := FDataLink.Field.AsString; end;
Override the component constructor Create method. In the implementation of Create, create the FDataLink object, and assign the private DataChange method to FDataLink's OnDataChange event. Example:
... public constructor Create(AOwner: TComponent); override; ... implementation constructor TMyDBPanel.Create(AOwner: TComponent); begin inherited Create(AOwner); FDataLink := TFieldDataLink.Create; FDataLink.OnDataChange := DataChange; end;
Override the component destructor Destroy method. In the implementation of Destroy, set OnDataChange to nil (avoids a GPF), and free FDatalink. Example:
... public destructor Destroy; override; ... implementation destructor TDBPanel.Destroy; begin FDataLink.OnDataChange := nil; FDataLink.Free; inherited Destroy; end;
Save the unit and install the component (see the Users Guide, and the Component Writers Guide in Delphi Help for more on saving units and installing components).
To test the functionality of the component, add a TTable, TDatasource, TDBNavigator and TDBPanel to a form. Set the TTable DatabaseName and TableName to 'DBDemos' and 'BioLife' respectively, and the Active property to True. Set the TDatasource.Dataset property to Table1. Set the TDBNavigator and TDBPanel.DataSource property to Datasource1. The TDBPanel.DataField name should be set as 'Common_Name'. Run the application and use the navigator to move between records to demonstrate the TDBPanel's ability to detect the change in data and display the appropriate field value.
unit Mydbp; interface uses SysUtils, WinTypes, WinProcs, Messages, Classes, Graphics, Controls, Forms, Dialogs, ExtCtrls, DB, DBTables; type TDBPanel = class(TCustomPanel) private FDataLink: TFieldDataLink; function GetDataField: String; function GetDataSource: TDataSource; procedure SetDataField(Const Value: string); procedure SetDataSource(Value: TDataSource); procedure DataChange(Sender: TObject); public constructor Create(AOwner: TComponent); override; destructor Destroy; override; published property DataField: string read GetDataField write SetDataField; property DataSource: TdataSource read GetDataSource write SetDataSource; end; procedure Register; implementation procedure Register; begin RegisterComponents('Samples', [TDBPanel]); end; function TDBPanel.GetDataField: String; begin Result := FDataLink.FieldName; end; function TDBPanel.GetDataSource: TDataSource; begin Result := FDataLink.DataSource; end; procedure TDBPanel.SetDataField(Const Value: string); begin FDataLink.FieldName := Value; end; procedure TDBPanel.SetDataSource(Value: TDataSource); begin FDataLink.DataSource := Value; end; procedure TDBPanel.DataChange(Sender: TObject); begin if FDataLink.Field = nil then Caption := '' else Caption := FDataLink.Field.AsString; end; constructor TDBPanel.Create(AOwner: TComponent); begin inherited Create(AOwner); FDataLink := TFieldDataLink.Create; FDataLink.OnDataChange := DataChange; end; destructor TDBPanel.Destroy; begin FDataLink.Free; FDataLink.OnDataChange := nil; inherited Destroy; end; end.


Awesome lets work together. If you have a project that has the potential to advance the industry's state of the art, or to otherwise do good in the world, we can help you make that happen.
We provide a range of services to help companies create forward-looking interfaces for connected devices, mobile apps, and responsive websites:


--- layout: page status: publish published: true title: Authentication the SSPI way author: display_name: Tomas Restrepo login: tomasr email<EMAIL_ADDRESS>url: http://winterdom.com/ author_login: tomasr author_email<EMAIL_ADDRESS>author_url: http://winterdom.com/ wordpress_id: 1153 wordpress_url: http://winterdom.com/?page_id=1153 date: '2009-04-29 00:55:00 +0000' date_gmt: '2009-04-29 00:55:00 +0000' categories: - Uncategorized tags: [] comments: - id: 2907 author: Amir author_email<EMAIL_ADDRESS>author_url: '' date: '2012-08-14 21:16:48 +0000' date_gmt: '2012-08-14 21:16:48 +0000' content: "This is great. I'm glad that you have done this, because I have been searching for a way to carry out a simple authentication (just pass/fail) with a kerberos 5 username and password against a kerberos kdc.\r\n\r\nI'm new to .NET, and I was able to do this in Java using the JAAS library. Could you provide some guidance as to how to do this with kerberos as opposed to NTLM?\r\n\r\nMy specific problem involves a client who wants to authenticate the users of his program against a university's kerberos5 kdc (on a different domain). How do you configure SSPI to authenticate against a specific kdc?" - id: 3359 author: Rifat author_email<EMAIL_ADDRESS>author_url: '' date: '2012-10-24 03:42:01 +0000' date_gmt: '2012-10-24 03:42:01 +0000' content: "Hi Amir,\r\nI am trying exactly to do something like that. But, I am failing to find out supporting documents/helps. Can you help me ?" ---
Many people ask frequently on the Microsoft Newsgroups how can
they verify that a username and password match against the SAM. Well, on NT, at
least, it turns out there are two different methods you can use:
LogonUser(): It's easy to use, and gives you an
access token you can use for impersonation later, but unfortunately,
requires that the caller holds the SeTcb privilege, which poses a great
security risk. The usual workaround is to create an authentication server
that runs as a service under the SYSTEM account and does the real work of
calling LogonUser().
SSPI: This is the Security Service Provider
Interface, which provides a set of APIs you can use to authenticate a
user, and acquire credentials for it. The problem with using SSPI is that is
complicated, and some aspects of it are not that well documented. To make
matter worse, the SSPI samples on the KB and Platform SDK leave a lot to be
desired. The nice thing about SSPI, on the other hand, is that it's
transport-neutral, as you are responsible for transmitting the packets
between client and server (which might be in the same process). Also, some
providers support message encription.
So, how can you use SSPI, in a single process, to
authenticate a given username and password? Here it is step by step:
QuerySecurityPackageInfo()
to obtain a SecPkgInfo
pointerFreeContextBuffer()
).
AcquireCredentialsHandle()
once. For the client, you need to do that,SEC_WINNT_AUTH_IDENTITY
struct and pass a pointer toAcquireCredentialsHandle()
as the 5th parameter. Keep in mind that youInitializeSecurityContext
(for the client side) followed byAcceptSecurityContext
(for the server side), passing theSEC_E_OK
AcceptSecurityContext()
returns SEC_E_OK, you still have toImpersonateSecurityContext()
will cause you toRevertSecurityContext()
.One important thing to notice while you are calling InitializeSecurityContext()
and AcceptSecurityContext()
is that one of those returns SEC_I_COMPLETE_NEEDED
or SEC_I_COMPLETE_AND_CONTINUE
, you need to call CompleteAuthToken().
If you are using SSPI in server/client applications, you should be aware of what I
consider a rather annoying problem with SSPI: The SSPI client is not notified of the
authentication results, and rather always returns SEC_E_OK
(unless another
error pops up) in the last round, even if the server later denies the logon request. This means
you need to make your server trap the return of the last call to AcceptSecurityContext()
and explicitly tell your client if the logon request was accepted or not.
I've built a C++ library that greatly simplifies the use of SSPI, while
keeping it transport-independent, giving the programmer control of the buffers.
Included in the package are:
Minor Comment: The library is very much oriented toward creating
authentication services built on top of NTLM or Kerb, so currently you won't be
able to (easily) support things like SCHANNEL. That's one of my goals for the
next version, but I really haven't had the time to sit down and start version
2.0
Get the file here: wsspi.zip
Update: WSSPI V2.0 development is pretty far ahead, so you should see it in a
couple of weeks. Currently, I'm testing the library implementation, and adding SCHANNEL support
to it. Here's some of the things you can expect:
EncryptMessage()
andMakeSignature()
Update 08/01/2001: There are finally two updates to WSSPI. The first one is courtesy of
Jim Johnson, which added support to the basic WSSPI 1.0 for message signing and verification. You can
get this version here.
Since I've been meaning to finish WSSPI 2.0 for so long, and have not posted anything, I decided to
post what's already built in case someone finds it useful. Note that this is a complete rewrite, from
scratch of WSSPI, called WSSPI 2.1, but it is unfinished. Mostly, the Kerberos support is broken.
You can get the file here


{% extends "email/email_base.html" %} {% block content %}
Your Google contacts have been imported to ContactOtter.
Cheers,
Contact Otter


The first blue day of imbecilic glee was a Tuesday towards the end of March. In truth, the day was not blue, for there was frightful storminess, a blizzard of hailstones, and much tempest and wrack. Nevertheless, when looking back, I remember other things. I remember how we laughed even though our picnic plans were dashed. I remember how we pretended the cow in the field was a Magus, bewitching us. I remember how we ran back to the house and spent the afternoon playing a game of Ayn Rand! Every time you shouted a sentence from The Fountainhead and I countered with one from Atlas Shrugged, the uproar was such that Mr Loog Oldham next door took off his big black boot and hammered on the wall. I remember the embers at the end of that first blue day.
The second blue day of imbecilic glee was that day we took our bicycles on the train to the fishing village at the end of the world and painted watercolours of the post office and bought stamps and drank Tizer and we were followed around the village by a one-eyed dog with terrible fangs and you wanted to take it home and all afternoon the shrill singing of the orphanage choir filled our ears and I found a tiny toy plastic pig in a thicket of stinging nettles and we cycled all the way home along that dangerous road as huge container lorries thundered past us in both directions.
The third blue day of imbecilic glee is today.


This is the audio assesment done by Joaquin Atienza, the audio is ment to represent a game ilustrate by the picture on the background of the page, in my mind I design the audio for a pirate/action type of gain, with some suspense music, from there I add the extra elements such as the water or a dog to create more realism.
-This audio assement is in a .wav format, the work was all done in Audacity and suggested in class.
-First of all I needed to learn how to use audacity, I watched some videos on cydia but I especialy recomend
this one.
-I then choose the pirate picture because of all the elemnts on it, thw water, the wood craking, the sounds of a port. After choosing it I download a lot of music thaht could help me in my work, most of it on this web
https://www.zapsplat.com.
-Adding all the elemnt was a risk and some of them had to dissapear, I Decided to includ the thunder and rain, the footsteps of someone while the wood is craking, a dog, because there is always a dog. Sadly my phase1 of the audio dissapear and I only have the final work that is on top of the web.
This is my work, I hope you enjoy it