swordfish

package
v0.9.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Mar 20, 2021 License: BSD-3-Clause Imports: 5 Imported by: 15

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AccessState 

type AccessState string

AccessState is used for associated resources through all aggregated endpoints shall share this access state. 

const (
	// OptimizedAccessState shall be in an Active/Optimized state.
	OptimizedAccessState AccessState = "Optimized"
	// NonOptimizedAccessState shall be in an Active/NonOptimized state.
	NonOptimizedAccessState AccessState = "NonOptimized"
	// StandbyAccessState shall be in a Standby state.
	StandbyAccessState AccessState = "Standby"
	// UnavailableAccessState shall be in an unavailable state.
	UnavailableAccessState AccessState = "Unavailable"
	// TransitioningAccessState shall be transitioning to a new AccessState.
	TransitioningAccessState AccessState = "Transitioning"
)

type AntiVirusScanTrigger 

type AntiVirusScanTrigger string

AntiVirusScanTrigger shall specify types of antivirus scan triggers. 

const (
	// NoneAntiVirusScanTrigger specifies there is no trigger.
	NoneAntiVirusScanTrigger AntiVirusScanTrigger = "None"
	// OnFirstReadAntiVirusScanTrigger specifies to trigger on first read.
	OnFirstReadAntiVirusScanTrigger AntiVirusScanTrigger = "OnFirstRead"
	// OnPatternUpdateAntiVirusScanTrigger specifies to trigger on antivirus
	// pattern file update.
	OnPatternUpdateAntiVirusScanTrigger AntiVirusScanTrigger = "OnPatternUpdate"
	// OnUpdateAntiVirusScanTrigger specifies to trigger on object update.
	OnUpdateAntiVirusScanTrigger AntiVirusScanTrigger = "OnUpdate"
	// OnRenameAntiVirusScanTrigger specifies to trigger on object rename.
	OnRenameAntiVirusScanTrigger AntiVirusScanTrigger = "OnRename"
)

type AuthenticationMethod 

type AuthenticationMethod string

AuthenticationMethod is method used to authenticate. 

const (
	// NoneAuthenticationMethod No authentication is used.
	NoneAuthenticationMethod AuthenticationMethod = "None"
	// CHAPAuthenticationMethod iSCSI Challenge Handshake Authentication
	// Protocol (CHAP) authentication is used.
	CHAPAuthenticationMethod AuthenticationMethod = "CHAP"
	// MutualCHAPAuthenticationMethod iSCSI Mutual Challenge Handshake
	// Authentication Protocol (CHAP) authentication is used.
	MutualCHAPAuthenticationMethod AuthenticationMethod = "MutualCHAP"
	// DHCHAPAuthenticationMethod Diffie-Hellman Challenge Handshake
	// Authentication Protocol (DHCHAP) is an authentication protocol used in
	// Fibre Channel. DHCHAP implies that only properties 'TargetCHAPUser'
	// and 'TargetPassword' need to be present.
	DHCHAPAuthenticationMethod AuthenticationMethod = "DHCHAP"
)

type AuthenticationType 

type AuthenticationType string

AuthenticationType shall specify authentication algorithms. 

const (
	// NoneAuthenticationType specifies No authentication.
	NoneAuthenticationType AuthenticationType = "None"
	// PKIAuthenticationType specifies a Public Key Infrastructure. Customers
	// with the highest assurance requirements roll PKI out to hosts and users
	// (it is more common for hosts than users. User PKI-based authentication
	// has significant operational complications and administrative overheads,
	// e.g., smart cards may be involved.
	PKIAuthenticationType AuthenticationType = "PKI"
	// TicketAuthenticationType specifies Ticket-
	// based (e.g., Kerberos): This is the most common class of
	// authentication infrastructure used in enterprises. Kerberos is the
	// best known example, and Windows usage of that via Active Directory is
	// so widely deployed as to be a de facto standard. In other areas (e.g.,
	// academia) there are comparable ticket-based systems.
	TicketAuthenticationType AuthenticationType = "Ticket"
	// PasswordAuthenticationType specifies
	// Password/shared-secret: Absent an distributed authentication
	// infrastructure, this is what is typically done.
	PasswordAuthenticationType AuthenticationType = "Password"
)

type CHAPInformation 

type CHAPInformation struct {
	// InitiatorCHAPPassword shall be the
	// shared secret for CHAP authentication.
	InitiatorCHAPPassword string
	// InitiatorCHAPUser is If present, this property is the initiator CHAP
	// username for authentication. For example, with an iSCSI scenario, use
	// the initiator iQN.
	InitiatorCHAPUser string
	// TargetCHAPUser shall be the CHAP
	// Username for 2-way CHAP authentication. For example, with an iSCSI
	// scenario, use the target iQN. In a FC with DHCHAP, this value will be
	// a FC WWN.
	TargetCHAPUser string
	// TargetPassword shall be the CHAP Secret
	// for 2-way CHAP authentication.
	TargetPassword string
}

CHAPInformation is used for CHAP auth.

type Capacity 

type Capacity struct {
	// Data shall be capacity information relating to provisioned user data.
	Data CapacityInfo
	// IsThinProvisioned is If the value is false, the capacity shall be
	// fully allocated. The default value shall be false.
	IsThinProvisioned bool
	// Metadata shall be capacity information relating to provisioned system
	// (non-user accessible) data.
	Metadata CapacityInfo
	// Snapshot shall be capacity information relating to
	// provisioned snapshot or backup data.
	Snapshot CapacityInfo
}

Capacity is used to represent storage capacity. The sum of the values in Data, Metadata, and Snapshot shall be equal to the total capacity for the data store.

type CapacityInfo 

type CapacityInfo struct {
	// AllocatedBytes shall be the number of bytes currently
	// allocated by the storage system in this data store for this data type.
	AllocatedBytes int64
	// ConsumedBytes shall be the number of logical bytes
	// currently consumed in this data store for this data type.
	ConsumedBytes int64
	// GuaranteedBytes shall be the number of bytes the storage
	// system guarantees can be allocated in this data store for this data
	// type.
	GuaranteedBytes int64
	// ProvisionedBytes shall be the maximum number of bytes
	// that can be allocated in this data store for this data type.
	ProvisionedBytes int64
}

CapacityInfo is used to represent the utilization of storage capacity.

type CapacitySource 

type CapacitySource struct {
	common.Entity

	// ODataContext is the odata context.
	ODataContext string `json:"@odata.context"`
	// ODataType is the odata type.
	ODataType string `json:"@odata.type"`
	// Description provides a description of this resource.
	Description string
	// ProvidedCapacity shall be the amount of space that has been provided from
	// the ProvidingDrives, ProvidingVolumes, ProvidingMemory or ProvidingPools.
	ProvidedCapacity Capacity
	// contains filtered or unexported fields
}

CapacitySource is used to represent the source and type of storage capacity. At most one of the ProvidingDrives, ProvidingVolumes, ProvidingMemoryChunks, ProvidingMemory or ProvidingPools properties may have a value. If any of ProvidingDrives, ProvidingVolumes, ProvidingMemory or ProvidingPools reference more than one resource, allocation of capacity across those resources is implementation dependent.

func GetCapacitySource 

func GetCapacitySource(c common.Client, uri string) (*CapacitySource, error)

GetCapacitySource will get a CapacitySource instance from the service.

func ListReferencedCapacitySources 

func ListReferencedCapacitySources(c common.Client, link string) ([]*CapacitySource, error)

ListReferencedCapacitySources gets the collection of CapacitySources from a provided reference.

func (*CapacitySource) ProvidedClassOfService 

func (capacitysource *CapacitySource) ProvidedClassOfService() (*ClassOfService, error)

ProvidedClassOfService gets the ClassOfService from the ProvidingDrives, ProvidingVolumes, ProvidingMemoryChunks, ProvidingMemory or ProvidingPools.

func (*CapacitySource) ProvidingDrives 

func (capacitysource *CapacitySource) ProvidingDrives() ([]*redfish.Drive, error)

ProvidingDrives gets contributing drives.

func (*CapacitySource) ProvidingMemory 

func (capacitysource *CapacitySource) ProvidingMemory() ([]*redfish.Memory, error)

ProvidingMemory gets contributing memory.

func (*CapacitySource) ProvidingPools 

func (capacitysource *CapacitySource) ProvidingPools() ([]*StoragePool, error)

ProvidingPools gets contributing pools.

func (*CapacitySource) ProvidingVolumes 

func (capacitysource *CapacitySource) ProvidingVolumes() ([]*Volume, error)

ProvidingVolumes gets contributing volumes.

func (*CapacitySource) UnmarshalJSON 

func (capacitysource *CapacitySource) UnmarshalJSON(b []byte) error

UnmarshalJSON unmarshals a CapacitySource object from the raw JSON.

type CharacterCodeSet 

type CharacterCodeSet string

CharacterCodeSet shall indicate the character code standards supported by the file system. 

const (
	// ASCIICharacterCodeSet shall indicate that the ASCII character encoding
	// is supported by the file system.
	ASCIICharacterCodeSet CharacterCodeSet = "ASCII"
	// UnicodeCharacterCodeSet shall indicate that Unicode character encoding
	// is supported by the file system.
	UnicodeCharacterCodeSet CharacterCodeSet = "Unicode"
	// ISO2022CharacterCodeSet shall indicate that ISO-2022 character
	// encoding is supported by the file system.
	ISO2022CharacterCodeSet CharacterCodeSet = "ISO2022"
	// ISO88591CharacterCodeSet shall indicate that ISO-8859-1 character
	// encoding is supported by the file system.
	ISO88591CharacterCodeSet CharacterCodeSet = "ISO8859_1"
	// ExtendedUNIXCodeCharacterCodeSet shall indicate that Extended Unix
	// Code character encoding is supported by the file system.
	ExtendedUNIXCodeCharacterCodeSet CharacterCodeSet = "ExtendedUNIXCode"
	// UTF8CharacterCodeSet shall indicate that the UTF-8 character encoding
	// is supported by the file system.
	UTF8CharacterCodeSet CharacterCodeSet = "UTF_8"
	// UTF16CharacterCodeSet shall indicate that the UTF-16 character
	// encoding is supported by the file system.
	UTF16CharacterCodeSet CharacterCodeSet = "UTF_16"
	// UCS2CharacterCodeSet shall indicate that the UCS-2 character encoding
	// is supported by the file system.
	UCS2CharacterCodeSet CharacterCodeSet = "UCS_2"
)

type ClassOfService 

type ClassOfService struct {
	common.Entity

	// ODataContext is the odata context.
	ODataContext string `json:"@odata.context"`
	// ODataType is the odata type.
	ODataType string `json:"@odata.type"`
	// ClassOfServiceVersion is the version describing the creation or last
	// modification of this service option specification. The string
	// representing the version shall be in the form: M + '.' + N + '.' + U
	// Where: M - The major version (in numeric form). N - The minor version
	// (in numeric form). U - The update (e.g. errata or patch in numeric
	// form).
	ClassOfServiceVersion string

	// DataProtectionLinesOfServiceCount is the number of DataProtectionLineOfService.
	DataProtectionLinesOfServiceCount int `json:"DataProtectionLinesOfService@odata.count"`

	// DataSecurityLinesOfServiceCount is number of DataSecurityLineOfService.
	DataSecurityLinesOfServiceCount int `json:"DataSecurityLinesOfService@odata.count"`

	// DataStorageLinesOfServiceCount is the number of DataStorageLinesOfService.
	DataStorageLinesOfServiceCount int `json:"DataStorageLinesOfService@odata.count"`
	// Description provides a description of this resource.
	Description string

	// IOConnectivityLinesOfServiceCount is the number of IOConnectivityLinesOfService.
	IOConnectivityLinesOfServiceCount int `json:"IOConnectivityLinesOfService@odata.count"`

	// IOPerformanceLinesOfServiceCount is the number of IOPerformanceLinesOfService.
	IOPerformanceLinesOfServiceCount int `json:"IOPerformanceLinesOfService@odata.count"`
	// Identifier shall be unique within the managed ecosystem.
	Identifier common.Identifier
	// contains filtered or unexported fields
}

ClassOfService shall define a service option composed of one or more line of service entities. ITIL defines a service option as a choice of utility or warranty for a service.

func GetClassOfService 

func GetClassOfService(c common.Client, uri string) (*ClassOfService, error)

GetClassOfService will get a ClassOfService instance from the service.

func ListReferencedClassOfServices 

func ListReferencedClassOfServices(c common.Client, link string) ([]*ClassOfService, error)

ListReferencedClassOfServices gets the collection of ClassOfService from a provided reference.

func (*ClassOfService) DataProtectionLinesOfServices 

func (classofservice *ClassOfService) DataProtectionLinesOfServices() ([]*DataProtectionLineOfService, error)

DataProtectionLinesOfServices gets the DataProtectionLinesOfService that are part of this ClassOfService.

func (*ClassOfService) DataSecurityLinesOfServices 

func (classofservice *ClassOfService) DataSecurityLinesOfServices() ([]*DataSecurityLineOfService, error)

DataSecurityLinesOfServices gets the DataSecurityLinesOfService that are part of this ClassOfService.

func (*ClassOfService) DataStorageLinesOfServices 

func (classofservice *ClassOfService) DataStorageLinesOfServices() ([]*DataStorageLineOfService, error)

DataStorageLinesOfServices gets the DataStorageLinesOfService that are part of this ClassOfService.

func (*ClassOfService) IOConnectivityLinesOfServices 

func (classofservice *ClassOfService) IOConnectivityLinesOfServices() ([]*IOConnectivityLineOfService, error)

IOConnectivityLinesOfServices gets the IOConnectivityLinesOfService that are part of this ClassOfService.

func (*ClassOfService) IOPerformanceLinesOfServices 

func (classofservice *ClassOfService) IOPerformanceLinesOfServices() ([]*IOPerformanceLineOfService, error)

IOPerformanceLinesOfServices gets the IOPerformanceLinesOfService that are part of this ClassOfService.

func (*ClassOfService) UnmarshalJSON 

func (classofservice *ClassOfService) UnmarshalJSON(b []byte) error

UnmarshalJSON unmarshals a ClassOfService object from the raw JSON.

type ConsistencyState 

type ConsistencyState string

ConsistencyState is used to describe the consistency type used by the source and its associated target group. 

const (
	// ConsistentConsistencyState shall indicate that the source and target
	// shall be consistent.
	ConsistentConsistencyState ConsistencyState = "Consistent"
	// InconsistentConsistencyState shall indicate that the source and target
	// are not required to be consistent.
	InconsistentConsistencyState ConsistencyState = "Inconsistent"
)

type ConsistencyStatus 

type ConsistencyStatus string

ConsistencyStatus is used to indicate the current status of consistency. Consistency may have been disabled or may be experiencing an error condition. 

const (
	// ConsistentConsistencyStatus shall indicate that the source and target
	// are consistent.
	ConsistentConsistencyStatus ConsistencyStatus = "Consistent"
	// InProgressConsistencyStatus shall indicate that the source and target
	// are becoming consistent.
	InProgressConsistencyStatus ConsistencyStatus = "InProgress"
	// DisabledConsistencyStatus shall indicate that the source and target
	// have consistency disabled.
	DisabledConsistencyStatus ConsistencyStatus = "Disabled"
	// InErrorConsistencyStatus shall indicate that the source and target are
	// not consistent.
	InErrorConsistencyStatus ConsistencyStatus = "InError"
)

type ConsistencyType 

type ConsistencyType string

ConsistencyType is used by the source and its associated target group. 

const (
	// SequentiallyConsistentConsistencyType shall indicate that the source
	// and target shall be sequentially consistent.
	SequentiallyConsistentConsistencyType ConsistencyType = "SequentiallyConsistent"
)

type DataProtectionLineOfService 

type DataProtectionLineOfService struct {
	common.Entity

	// ODataContext is the odata context.
	ODataContext string `json:"@odata.context"`
	// ODataType is the odata type.
	ODataType string `json:"@odata.type"`
	// Description provides a description of this resource.
	Description string
	// IsIsolated is True shall indicate that the replica is in a separate
	// fault domain from its source. The default value of this property is
	// false.
	IsIsolated bool
	// MinLifetime shall be an ISO 8601 duration that specifies
	// the minimum required lifetime of the replica. Note: The maximum number
	// of replicas can be determined using this value together with the
	// replicaSchedule.
	MinLifetime string
	// RecoveryGeographicObjective specifies the geographic scope of the failure
	// domain.
	RecoveryGeographicObjective FailureDomainScope
	// RecoveryPointObjectiveTime shall be an ISO 8601 duration that specifies
	// the maximum time over which source data may be lost on failure. In the
	// case that IsIsolated = false, failure of the domain is not a
	// consideration.
	RecoveryPointObjectiveTime string
	// RecoveryTimeObjective shall be an enumeration that
	// indicates the maximum time required to access an alternate replica. In
	// the case that IsIsolated = false, failure of the domain is not a
	// consideration.
	RecoveryTimeObjective RecoveryAccessScope
	// ReplicaAccessLocation is used if the data access location of the
	// replica is required to be at a specific location.   Note 1: The
	// location value may be granular.  Note 2: A value may be required for
	// some regulatory compliance.
	ReplicaAccessLocation common.Location
	// ReplicaClassOfService shall reference the class of
	// service that defines the required service levels of the replica.
	ReplicaClassOfService ClassOfService
	// ReplicaType is the type of replica.
	ReplicaType ReplicaType
	// Schedule if a replica is made periodically, the value shall define
	// the schedule.
	Schedule common.Schedule
}

DataProtectionLineOfService describes a replica that protects data from loss. The requirements must be met collectively by the communication path and the replica.

func GetDataProtectionLineOfService 

func GetDataProtectionLineOfService(c common.Client, uri string) (*DataProtectionLineOfService, error)

GetDataProtectionLineOfService will get a DataProtectionLineOfService instance from the service.

func ListReferencedDataProtectionLineOfServices 

func ListReferencedDataProtectionLineOfServices(c common.Client, link string) ([]*DataProtectionLineOfService, error)

ListReferencedDataProtectionLineOfServices gets the collection of DataProtectionLineOfService from a provided reference.

type DataProtectionLoSCapabilities 

type DataProtectionLoSCapabilities struct {
	common.Entity

	// ODataContext is the odata context.
	ODataContext string `json:"@odata.context"`
	// ODataType is the odata type.
	ODataType string `json:"@odata.type"`
	// Description provides a description of this resource.
	Description string
	// Identifier shall be unique within the managed ecosystem.
	Identifier common.Identifier

	// SupportedLinesOfService@odata.count is
	SupportedLinesOfServiceCount int `json:"SupportedLinesOfService@odata.count"`
	// SupportedMinLifetimes each entry shall be an ISO 8601 duration that
	// specifies the minimum lifetime required for the replica.
	SupportedMinLifetimes []string
	// SupportedRecoveryGeographicObjectives each entry shall specify a
	// supported failure domain.
	SupportedRecoveryGeographicObjectives []FailureDomainScope
	// SupportedRecoveryPointObjectiveTimes each entry shall specify a supported
	// ISO 8601 time interval defining the maximum source information that may
	// be lost on failure. In the case that IsIsolated = false, failure of the
	// domain is not a consideration.
	SupportedRecoveryPointObjectiveTimes []string
	// SupportedRecoveryTimeObjectives each entry shall specify an enumerated
	// value that indicates a supported expectation for the time required to
	// access an alternate replica. In the case that IsIsolated = false, failure
	// of the domain is not a consideration.
	SupportedRecoveryTimeObjectives []RecoveryAccessScope
	// SupportedReplicaTypes each entry shall specify a supported replica type,
	SupportedReplicaTypes []ReplicaType
	// SupportsIsolated is A value of true shall indicate that allocating a
	// replica in a separate fault domain is supported. The default value for
	// this property is false.
	SupportsIsolated bool
	// SupportedReplicaOptionsCount is the number of supported replica options.
	SupportedReplicaOptionsCount int
	// contains filtered or unexported fields
}

DataProtectionLoSCapabilities is the capabilities to protect data from loss by the use of a replica. The requirements shall be met collectively by the communication path and the replica. There should be one instance associated to a class of service for each replica. Each replica independently should have a class of service that describes its characteristics.

func GetDataProtectionLoSCapabilities 

func GetDataProtectionLoSCapabilities(c common.Client, uri string) (*DataProtectionLoSCapabilities, error)

GetDataProtectionLoSCapabilities will get a DataProtectionLoSCapabilities instance from the service.

func ListReferencedDataProtectionLoSCapabilities 

func ListReferencedDataProtectionLoSCapabilities(c common.Client, link string) ([]*DataProtectionLoSCapabilities, error)

ListReferencedDataProtectionLoSCapabilities gets the collection of DataProtectionLoSCapabilities from a provided reference.

func (*DataProtectionLoSCapabilities) SupportedLinesOfService 

func (dataprotectionloscapabilities *DataProtectionLoSCapabilities) SupportedLinesOfService() ([]*DataProtectionLineOfService, error)

SupportedLinesOfService gets the supported lines of service.

func (*DataProtectionLoSCapabilities) SupportedReplicaOptions 

func (dataprotectionloscapabilities *DataProtectionLoSCapabilities) SupportedReplicaOptions() ([]*ClassOfService, error)

SupportedReplicaOptions gets the support replica ClassesOfService.

func (*DataProtectionLoSCapabilities) UnmarshalJSON 

func (dataprotectionloscapabilities *DataProtectionLoSCapabilities) UnmarshalJSON(b []byte) error

UnmarshalJSON unmarshals a DataProtectionLoSCapabilities object from the raw JSON.

func (*DataProtectionLoSCapabilities) Update added in v0.5.0 

func (dataprotectionloscapabilities *DataProtectionLoSCapabilities) Update() error

Update commits updates to this object's properties to the running system.

type DataSanitizationPolicy 

type DataSanitizationPolicy string

DataSanitizationPolicy shall specify types of data sanitization policies. 

const (
	// NoneDataSanitizationPolicy specifies no sanitization.
	NoneDataSanitizationPolicy DataSanitizationPolicy = "None"
	// ClearDataSanitizationPolicy specifies to
	// sanitize data in all user-addressable storage locations for protection
	// against simple non-invasive data recovery techniques.
	ClearDataSanitizationPolicy DataSanitizationPolicy = "Clear"
	// CryptographicEraseDataSanitizationPolicy This enumeration literal
	// specifies to leverages the encryption of target data by enabling
	// sanitization of the target data's encryption key. This leaves only the
	// ciphertext remaining on the media, effectively sanitizing the data by
	// preventing read-access. For more information, see NIST800-88 and
	// ISO/IEC 27040.
	CryptographicEraseDataSanitizationPolicy DataSanitizationPolicy = "CryptographicErase"
)

type DataSecurityLineOfService 

type DataSecurityLineOfService struct {
	common.Entity

	// ODataContext is the odata context.
	ODataContext string `json:"@odata.context"`
	// ODataType is the odata type.
	ODataType string `json:"@odata.type"`
	// AntivirusEngineProvider shall specify an AntiVirus provider.
	AntivirusEngineProvider string
	// AntivirusScanPolicies shall specify the
	// policy for triggering an AntiVirus scan.
	AntivirusScanPolicies []AntiVirusScanTrigger
	// ChannelEncryptionStrength shall specify a key size in a symmetric
	// encryption algorithm for transport channel encryption.
	ChannelEncryptionStrength KeySize
	// DataSanitizationPolicy shall specify the data sanitization policy.
	DataSanitizationPolicy DataSanitizationPolicy
	// Description provides a description of this resource.
	Description string
	// HostAuthenticationType shall specify the
	// authentication type for hosts (servers) or initiator endpoints.
	HostAuthenticationType AuthenticationType
	// MediaEncryptionStrength shall specify a key
	// size in a symmetric encryption algorithm for media encryption.
	MediaEncryptionStrength KeySize
	// SecureChannelProtocol shall specify the
	// protocol that provide encrypted communication.
	SecureChannelProtocol SecureChannelProtocol
	// UserAuthenticationType shall specify the
	// authentication type for users (or programs).
	UserAuthenticationType AuthenticationType
}

DataSecurityLineOfService is used to describe data security service level requirements.

func GetDataSecurityLineOfService 

func GetDataSecurityLineOfService(c common.Client, uri string) (*DataSecurityLineOfService, error)

GetDataSecurityLineOfService will get a DataSecurityLineOfService instance from the service.

func ListReferencedDataSecurityLineOfServices 

func ListReferencedDataSecurityLineOfServices(c common.Client, link string) ([]*DataSecurityLineOfService, error)

ListReferencedDataSecurityLineOfServices gets the collection of DataSecurityLineOfService from a provided reference.

type DataSecurityLoSCapabilities 

type DataSecurityLoSCapabilities struct {
	common.Entity

	// ODataContext is the odata context.
	ODataContext string `json:"@odata.context"`
	// ODataType is the odata type.
	ODataType string `json:"@odata.type"`
	// Description provides a description of this resource.
	Description string
	// Identifier shall be unique within the managed ecosystem.
	Identifier common.Identifier
	// SupportedAntivirusEngineProviders shall specify supported AntiVirus providers.
	SupportedAntivirusEngineProviders []string
	// SupportedAntivirusScanPolicies shall specify supported policies that
	// trigger an AntiVirus scan.
	SupportedAntivirusScanPolicies []AntiVirusScanTrigger
	// SupportedChannelEncryptionStrengths shall specify supported key sizes in
	// a symmetric encryption algorithm (AES) for transport channel encryption.
	SupportedChannelEncryptionStrengths []KeySize
	// SupportedDataSanitizationPolicies shall specify supported data
	// sanitization policies.
	SupportedDataSanitizationPolicies []DataSanitizationPolicy
	// SupportedHostAuthenticationTypes shall specify supported authentication
	// types for hosts (servers) or initiator endpoints.
	SupportedHostAuthenticationTypes []AuthenticationType
	// SupportedLinesOfService shall contain supported DataSecurity service options.
	SupportedLinesOfService []DataSecurityLineOfService
	// SupportedLinesOfServiceCount is the number of supported lines of service.
	SupportedLinesOfServiceCount int `json:"SupportedLinesOfService@odata.count"`
	// SupportedMediaEncryptionStrengths shall specify supported key sizes in a
	// symmetric encryption algorithm (AES) for media encryption.
	SupportedMediaEncryptionStrengths []KeySize
	// SupportedSecureChannelProtocols shall specify supported protocols that
	// provide encrypted communication.
	SupportedSecureChannelProtocols []SecureChannelProtocol
	// SupportedUserAuthenticationTypes shall specify supported authentication
	// types for users (or programs).
	SupportedUserAuthenticationTypes []AuthenticationType
}

DataSecurityLoSCapabilities is used to describe data security capabilities.

func GetDataSecurityLoSCapabilities 

func GetDataSecurityLoSCapabilities(c common.Client, uri string) (*DataSecurityLoSCapabilities, error)

GetDataSecurityLoSCapabilities will get a DataSecurityLoSCapabilities instance from the service.

func ListReferencedDataSecurityLoSCapabilities 

func ListReferencedDataSecurityLoSCapabilities(c common.Client, link string) ([]*DataSecurityLoSCapabilities, error)

ListReferencedDataSecurityLoSCapabilities gets the collection of DataSecurityLoSCapabilities from a provided reference.

type DataStorageLineOfService 

type DataStorageLineOfService struct {
	common.Entity

	// ODataContext is the odata context.
	ODataContext string `json:"@odata.context"`
	// ODataType is the odata type.
	ODataType string `json:"@odata.type"`
	// AccessCapabilities is Each entry specifies a required storage access
	// capability.
	AccessCapabilities []StorageAccessCapability
	// Description provides a description of this resource.
	Description string
	// IsSpaceEfficient is A value of true shall indicate that the storage is
	// compressed or deduplicated. The default value for this property is
	// false.
	IsSpaceEfficient bool
	// Oem is The value of this string shall be of the format for the
	// reserved word *Oem*.
	OEM string `json:"Oem"`
	// ProvisioningPolicy is The enumeration literal shall define the
	// provisioning policy for storage.
	ProvisioningPolicy ProvisioningPolicy
	// RecoverableCapacitySourceCount is The value is minimum required number
	// of available capacity source resources that shall be available in the
	// event that an equivalent capacity source resource fails.  It is
	// assumed that drives and memory components can be replaced, repaired or
	// otherwise added to increase an associated resource's
	// RecoverableCapacitySourceCount.
	RecoverableCapacitySourceCount int
	// RecoveryTimeObjectives is The enumeration literal specifies the time
	// after a disaster that the client shall regain conformant service level
	// access to the primary store, typical values are 'immediate' or
	// 'offline'. The expectation is that the services required to implement
	// this capability are part of the advertising system.
	RecoveryTimeObjectives RecoveryAccessScope
}

DataStorageLineOfService is used to describe a service option covering storage provisioning and availability.

func GetDataStorageLineOfService 

func GetDataStorageLineOfService(c common.Client, uri string) (*DataStorageLineOfService, error)

GetDataStorageLineOfService will get a DataStorageLineOfService instance from the service.

func ListReferencedDataStorageLineOfServices 

func ListReferencedDataStorageLineOfServices(c common.Client, link string) ([]*DataStorageLineOfService, error)

ListReferencedDataStorageLineOfServices gets the collection of DataStorageLineOfService from a provided reference.

func (*DataStorageLineOfService) UnmarshalJSON 

func (datastoragelineofservice *DataStorageLineOfService) UnmarshalJSON(b []byte) error

UnmarshalJSON unmarshals a DataStorageLineOfService object from the raw JSON.

type DataStorageLoSCapabilities 

type DataStorageLoSCapabilities struct {
	common.Entity

	// ODataContext is the odata context.
	ODataContext string `json:"@odata.context"`
	// ODataType is the odata type.
	ODataType string `json:"@odata.type"`
	// Description provides a description of this resource.
	Description string
	// Identifier shall be unique within the managed ecosystem.
	Identifier common.Identifier
	// MaximumRecoverableCapacitySourceCount is the maximum number of capacity
	// source resources that can be supported for the purpose of recovery when
	// in the event that an equivalent capacity source resource fails.
	MaximumRecoverableCapacitySourceCount int
	// SupportedAccessCapabilities specifies a storage access capabilities.
	SupportedAccessCapabilities []StorageAccessCapability
	// SupportedLinesOfService shall contain known and supported DataStorageLinesOfService.
	SupportedLinesOfService []DataStorageLineOfService
	// SupportedLinesOfServiceCount is
	SupportedLinesOfServiceCount int `json:"SupportedLinesOfService@odata.count"`
	// SupportedProvisioningPolicies specifies supported storage allocation policies.
	SupportedProvisioningPolicies []ProvisioningPolicy
	// SupportedRecoveryTimeObjectives specifies supported expectations for time
	// to access the primary store after recovery.
	SupportedRecoveryTimeObjectives []RecoveryAccessScope
	// SupportsSpaceEfficiency specifies whether storage compression or
	// deduplication is supported. The default value for this property is false.
	SupportsSpaceEfficiency bool
	// contains filtered or unexported fields
}

DataStorageLoSCapabilities describes capabilities of the system to support various data storage service options.

func GetDataStorageLoSCapabilities 

func GetDataStorageLoSCapabilities(c common.Client, uri string) (*DataStorageLoSCapabilities, error)

GetDataStorageLoSCapabilities will get a DataStorageLoSCapabilities instance from the service.

func ListReferencedDataStorageLoSCapabilities 

func ListReferencedDataStorageLoSCapabilities(c common.Client, link string) ([]*DataStorageLoSCapabilities, error)

ListReferencedDataStorageLoSCapabilities gets the collection of DataStorageLoSCapabilities from a provided reference.

func (*DataStorageLoSCapabilities) UnmarshalJSON added in v0.5.0 

func (datastorageloscapabilities *DataStorageLoSCapabilities) UnmarshalJSON(b []byte) error

UnmarshalJSON unmarshals a DataStorageLoSCapabilities object from the raw JSON.

func (*DataStorageLoSCapabilities) Update added in v0.5.0 

func (datastorageloscapabilities *DataStorageLoSCapabilities) Update() error

Update commits updates to this object's properties to the running system.

type EndpointGroup 

type EndpointGroup struct {
	common.Entity

	// ODataContext is the odata context.
	ODataContext string `json:"@odata.context"`
	// ODataType is the odata type.
	ODataType string `json:"@odata.type"`
	// AccessState is used for associated resources through all
	// aggregated endpoints shall share this access state.
	AccessState AccessState
	// Description provides a description of this resource.
	Description string

	// EndpointsCount is the number of Endpoints
	EndpointsCount int
	// GroupType contains only endpoints of a given type
	// Client/Initiator or Server/Target.  If this endpoint group represents
	// a SCSI target group, the value of GroupType shall be Server.
	GroupType GroupType
	// Identifier shall be unique within the managed ecosystem.
	Identifier common.Identifier
	// Preferred with a value of True shall indicate that
	// access to the associated resource through the endpoints in this
	// endpoint group is preferred over access through other endpoints. The
	// default value for this property is false.
	Preferred bool
	// TargetEndpointGroupIdentifier represents a
	// SCSI target group, the value of this property shall contain a SCSI
	// defined identifier for this group, which corresponds to the TARGET
	// PORT GROUP field in the REPORT TARGET PORT GROUPS response and the
	// TARGET PORT GROUP field in an INQUIRY VPD page 85 response, type 5h
	// identifier. See the INCITS SAM-5 specification.
	TargetEndpointGroupIdentifier int
	// contains filtered or unexported fields
}

EndpointGroup is a group of endpoints that shall be managed as a unit.

func GetEndpointGroup 

func GetEndpointGroup(c common.Client, uri string) (*EndpointGroup, error)

GetEndpointGroup will get a EndpointGroup instance from the service.

func ListReferencedEndpointGroups 

func ListReferencedEndpointGroups(c common.Client, link string) ([]*EndpointGroup, error)

ListReferencedEndpointGroups gets the collection of EndpointGroup from a provided reference.

func (*EndpointGroup) Endpoints 

func (endpointgroup *EndpointGroup) Endpoints() ([]*redfish.Endpoint, error)

Endpoints gets the group's endpoints.

func (*EndpointGroup) UnmarshalJSON 

func (endpointgroup *EndpointGroup) UnmarshalJSON(b []byte) error

UnmarshalJSON unmarshals a EndpointGroup object from the raw JSON.

func (*EndpointGroup) Update added in v0.5.0 

func (endpointgroup *EndpointGroup) Update() error

Update commits updates to this object's properties to the running system.

type FailureDomainScope 

type FailureDomainScope string

FailureDomainScope shall represent a geographic scope in which all components within that scope have similar vulnerabilities. 

const (
	// ServerFailureDomainScope are components of a CPU/memory complex that share
	// the same infrastructure.
	ServerFailureDomainScope FailureDomainScope = "Server"
	// RackFailureDomainScope is a container within a datacenter that provides
	// communication, power, or cooling to a set of components.
	RackFailureDomainScope FailureDomainScope = "Rack"
	// RackGroupFailureDomainScope is a set of racks that may share common
	// communication, power, or cooling.
	RackGroupFailureDomainScope FailureDomainScope = "RackGroup"
	// RowFailureDomainScope is a set of adjacent racks or rackgroups that may
	// share common communication, power, or cooling.
	RowFailureDomainScope FailureDomainScope = "Row"
	// DatacenterFailureDomainScope is a facility that provides communication,
	// power, or cooling infrastructure to a co-located set of servers,
	// networking and storage.
	DatacenterFailureDomainScope FailureDomainScope = "Datacenter"
	// RegionFailureDomainScope is a set of resources that are required to be
	// either geographically or politically isolated from resources not in
	// the resources.
	RegionFailureDomainScope FailureDomainScope = "Region"
)

type FileProtocol 

type FileProtocol string

FileProtocol shall indicate the file sharing protocols supported by the file system. At least one value shall be present. 

const (
	// NFSv3FileProtocol shall indicate that NFSv3, as defined in RFC 1813,
	// is supported by the file system.
	NFSv3FileProtocol FileProtocol = "NFSv3"
	// NFSv40FileProtocol shall indicate that NFSv4, as defined in RFC 7530,
	// is supported by the file system.
	NFSv40FileProtocol FileProtocol = "NFSv4_0"
	// NFSv41FileProtocol shall indicate that NFSv4.1, as defined in RFC
	// 5661, is supported by the file system.
	NFSv41FileProtocol FileProtocol = "NFSv4_1"
	// SMBv20FileProtocol shall indicate that Server Message Block version
	// 2.0 is supported by the file system.
	SMBv20FileProtocol FileProtocol = "SMBv2_0"
	// SMBv21FileProtocol shall indicate that Server Message Block version
	// 2.1 is supported by the file system.
	SMBv21FileProtocol FileProtocol = "SMBv2_1"
	// SMBv30FileProtocol shall indicate that Server Message Block version
	// 3.0 is supported by the file system.
	SMBv30FileProtocol FileProtocol = "SMBv3_0"
	// SMBv302FileProtocol shall indicate that Server Message Block version
	// 3.0.2 is supported by the file system.
	SMBv302FileProtocol FileProtocol = "SMBv3_0_2"
	// SMBv311FileProtocol shall indicate that Server Message Block version
	// 3.1.1 is supported by the file system.
	SMBv311FileProtocol FileProtocol = "SMBv3_1_1"
)

type FileShare 

type FileShare struct {
	common.Entity

	// ODataContext is the odata context.
	ODataContext string `json:"@odata.context"`
	// ODataType is the odata type.
	ODataType string `json:"@odata.type"`
	// CASupported shall indicate that Continuous Availability is supported.
	// Client/Server mediated recovery from network and server failure with
	// application transparency. This property shall be NULL unless the
	// FileSharingProtocols property includes SMB. The default value for this
	// property is false.
	CASupported bool
	// DefaultAccessCapabilities shall be an array containing entries for the
	// default access capabilities for the file share. Each entry shall specify
	// a default access privilege. The types of default access can include Read,
	// Write, and/or Execute.
	DefaultAccessCapabilities []StorageAccessCapability
	// Description provides a description of this resource.
	Description string

	// ExecuteSupport shall indicate whether Execute access is supported by the
	// file share. The default value for this property is false.
	ExecuteSupport bool
	// FileSharePath shall be a path (relative to the file system root) to the
	// exported file or directory on the file system where this file share is
	// hosted.
	FileSharePath string
	// FileShareQuotaType value of Soft shall specify that quotas are not
	// enforced, and a value of Hard shall specify that writes shall fail if the
	// space consumed would exceed the value of the FileShareTotalQuotaBytes
	// property.
	FileShareQuotaType QuotaType
	// FileShareRemainingQuotaBytes value of this property shall indicate the
	// remaining number of bytes that may be consumed by this file share.
	FileShareRemainingQuotaBytes int64
	// FileShareTotalQuotaBytes value of this property shall indicate the
	// maximum number of bytes that may be consumed by this file share.
	FileShareTotalQuotaBytes int64
	// FileSharingProtocols is This property shall be an array containing
	// entries for the file sharing protocols supported by this file share.
	// Each entry shall specify a file sharing protocol supported by the file
	// system.
	FileSharingProtocols []FileProtocol
	// LowSpaceWarningThresholdPercents is This property shall be an array
	// containing entries for the percentages of file share capacity at which
	// low space warning events are be issued. A LOW_SPACE_THRESHOLD_WARNING
	// event shall be triggered each time the remaining file share capacity
	// value becomes less than one of the values in the array. The following
	// shall be true: Across all CapacitySources entries, percent =
	// (SUM(AllocatedBytes) - SUM(ConsumedBytes))/SUM(AllocatedBytes)
	LowSpaceWarningThresholdPercents []int
	// RemainingCapacityPercent is If present, this value shall return
	// {[(SUM(AllocatedBytes) - SUM(ConsumedBytes)]/SUM(AllocatedBytes)}*100
	// represented as an integer value.
	RemainingCapacityPercent int
	// RootAccess shall indicate whether Root
	// access is allowed by the file share. The default value for this
	// property is false.
	RootAccess bool
	// Status is This value of this property shall indicate the status of the
	// file share.
	Status common.Status
	// WritePolicy shall define how writes are
	// replicated to the shared source.
	WritePolicy ReplicaUpdateMode
	// contains filtered or unexported fields
}

FileShare is used to represent a shared set of files with a common directory structure.

func GetFileShare 

func GetFileShare(c common.Client, uri string) (*FileShare, error)

GetFileShare will get a FileShare instance from the service.

func ListReferencedFileShares 

func ListReferencedFileShares(c common.Client, link string) ([]*FileShare, error)

ListReferencedFileShares gets the collection of FileShare from a provided reference.

func (*FileShare) ClassOfService 

func (fileshare *FileShare) ClassOfService() (*ClassOfService, error)

ClassOfService gets the file share's class of service.

func (*FileShare) EthernetInterfaces 

func (fileshare *FileShare) EthernetInterfaces() ([]*redfish.EthernetInterface, error)

EthernetInterfaces gets the EthernetInterfaces associated with this share.

func (*FileShare) FileSystem 

func (fileshare *FileShare) FileSystem() (*FileSystem, error)

FileSystem gets the file share's associated file system.

func (*FileShare) UnmarshalJSON 

func (fileshare *FileShare) UnmarshalJSON(b []byte) error

UnmarshalJSON unmarshals a FileShare object from the raw JSON.

func (*FileShare) Update added in v0.5.0 

func (fileshare *FileShare) Update() error

Update commits updates to this object's properties to the running system.

type FileSystem 

type FileSystem struct {
	common.Entity

	// ODataContext is the odata context.
	ODataContext string `json:"@odata.context"`
	// ODataType is the odata type.
	ODataType string `json:"@odata.type"`
	// AccessCapabilities shall be an array containing entries for the supported
	// IO access capabilities. Each entry shall specify a current storage access
	// capability.
	AccessCapabilities []StorageAccessCapability
	// BlockSizeBytes shall be the block size of the file system in bytes.
	BlockSizeBytes int64
	// Capacity shall be the capacity allocated to the file system in bytes.
	Capacity Capacity
	// CapacitySources shall be an array containing entries for all the capacity
	// sources for the file system. Each entry shall provide capacity allocation
	// information from a named resource.
	CapacitySources []CapacitySource
	// CapacitySourcesCount is the number of CapacitySource entries.
	CapacitySourcesCount int `json:"CapacitySources@odata.count"`
	// CasePreserved shall indicate that the case of file names is preserved by
	// the file system. A value of True shall indicate that case of file names
	// shall be preserved.
	CasePreserved bool
	// CaseSensitive shall indicate that case sensitive file names are supported
	// by the file system. A value of True shall indicate that file names are
	// case sensitive.
	CaseSensitive bool
	// CharacterCodeSet shall be an array containing entries for the character
	// sets or encodings supported by the file system. Each entry shall specify
	// a character set encoding supported by the file system.
	CharacterCodeSet []CharacterCodeSet
	// ClusterSizeBytes shall specify the minimum file allocation size imposed
	// by the file system. This minimum allocation size shall be the smallest
	// amount of storage allocated to a file by the file system. Under stress
	// conditions, the file system may allocate storage in amounts smaller than
	// this value.
	ClusterSizeBytes int
	// Description provides a description of this resource.
	Description string
	// Identifiers shall contain a list of all known durable names for this file
	// system.
	Identifiers []common.Identifier
	// IOStatistics shall represent IO statistics for this FileSystem.
	IOStatistics IOStatistics
	// LowSpaceWarningThresholdPercents shall be an array containing entries for
	// the percentages of file system capacity at which low space warning events
	// are be issued. A LOW_SPACE_THRESHOLD_WARNING event shall be triggered
	// each time the remaining file system capacity value becomes less than one
	// of the values in the array. The following shall be true: Across all
	// CapacitySources entries, percent = (SUM(AllocatedBytes) -
	// SUM(ConsumedBytes))/SUM(AllocatedBytes)
	LowSpaceWarningThresholdPercents []int
	// MaxFileNameLengthBytes shall specify the maximum length of a file name
	// within the file system.
	MaxFileNameLengthBytes int64
	// RecoverableCapacitySourceCount is the number of available capacity source
	// resources currently available in the event that an equivalent capacity
	// source resource fails.
	RecoverableCapacitySourceCount int
	// RemainingCapacityPercent is If present, this value shall return
	// {[(SUM(AllocatedBytes) - SUM(ConsumedBytes)]/SUM(AllocatedBytes)}*100
	// represented as an integer value.
	RemainingCapacityPercent int
	// ReplicaInfo if this file system is a replica, this value shall
	// describe its replication attributes. This value shall not be present
	// if this file system is not a replica. A file system may be both a
	// source and a replica.
	ReplicaInfo ReplicaInfo
	// ReplicaTargetCount is the number of replica targets.
	ReplicaTargetsCount int `json:"ReplicaTargets@odata.count"`

	// ReplicaCollectionCount is the number of replica collections.
	ReplicaCollectionCount int

	// SpareResourceSetsCount is the number of spare resource sets.
	SpareResourceSetsCount int
	// contains filtered or unexported fields
}

FileSystem is used to represent an instance of a hierarchical namespace of files.

func GetFileSystem 

func GetFileSystem(c common.Client, uri string) (*FileSystem, error)

GetFileSystem will get a FileSystem instance from the service.

func ListReferencedFileSystems 

func ListReferencedFileSystems(c common.Client, link string) ([]*FileSystem, error)

ListReferencedFileSystems gets the collection of FileSystem from a provided reference.

func (*FileSystem) ClassOfService 

func (filesystem *FileSystem) ClassOfService() (*ClassOfService, error)

ClassOfService gets the filesystem's class of service.

func (*FileSystem) ExportedShares 

func (filesystem *FileSystem) ExportedShares() ([]*FileShare, error)

ExportedShares gets the exported file shares for this file system.

func (*FileSystem) SpareResourceSets 

func (filesystem *FileSystem) SpareResourceSets() ([]*SpareResourceSet, error)

SpareResourceSets gets the spare resource sets used for this filesystem.

func (*FileSystem) UnmarshalJSON 

func (filesystem *FileSystem) UnmarshalJSON(b []byte) error

UnmarshalJSON unmarshals a FileSystem object from the raw JSON.

func (*FileSystem) Update added in v0.5.0 

func (filesystem *FileSystem) Update() error

Update commits updates to this object's properties to the running system.

type FileSystemPersistenceType 

type FileSystemPersistenceType string

FileSystemPersistenceType shall indicate the persistence characteristics of the file system. 

const (
	// PersistentFileSystemPersistenceType shall indicate that the file
	// system is persistent, and shall be preserved through an orderly
	// shutdown.
	PersistentFileSystemPersistenceType FileSystemPersistenceType = "Persistent"
	// TemporaryFileSystemPersistenceType shall indicate that the file system
	// is non-persistent and may not survive a shutdown.
	TemporaryFileSystemPersistenceType FileSystemPersistenceType = "Temporary"
	// OtherFileSystemPersistenceType shall indicate that the persistence
	// type is known, but not defined by this standard. Use of this value is
	// not recommended.
	OtherFileSystemPersistenceType FileSystemPersistenceType = "Other"
)

type GroupType 

type GroupType string

GroupType is the type of endpoint grouping. 

const (
	// ClientGroupType The group contains the client (initiator) endpoints.
	ClientGroupType GroupType = "Client"
	// ServerGroupType The group contains the server (target) endpoints.
	ServerGroupType GroupType = "Server"
)

type IOAccessPattern 

type IOAccessPattern string

IOAccessPattern is used to specify an IO access pattern. 

const (
	// ReadWriteIOAccessPattern shall indicate a Uniform distribution of
	// reads and writes.
	ReadWriteIOAccessPattern IOAccessPattern = "ReadWrite"
	// SequentialReadIOAccessPattern shall indicate a sequential read pattern
	// of access.
	SequentialReadIOAccessPattern IOAccessPattern = "SequentialRead"
	// SequentialWriteIOAccessPattern shall indicate a sequential write
	// pattern of access.
	SequentialWriteIOAccessPattern IOAccessPattern = "SequentialWrite"
	// RandomReadNewIOAccessPattern shall indicate an access pattern of
	// random reads of uncached data.
	RandomReadNewIOAccessPattern IOAccessPattern = "RandomReadNew"
	// RandomReadAgainIOAccessPattern shall indicate an access pattern of
	// random reads of cached data.
	RandomReadAgainIOAccessPattern IOAccessPattern = "RandomReadAgain"
)

type IOConnectivityLineOfService 

type IOConnectivityLineOfService struct {
	common.Entity

	// ODataContext is the odata context.
	ODataContext string `json:"@odata.context"`
	// ODataType is the odata type.
	ODataType string `json:"@odata.type"`
	// AccessProtocols shall specify the Access protocol for this service
	// option. NOTE: If multiple protocols are specified,  the corresponding
	// MaxSupportedIOPS governs the max achieved across all protocol uses. This
	// may be less than the sum of the individual max values, which may be
	// specified by individual Line of Service entries.
	AccessProtocols []common.Protocol
	// Description provides a description of this resource.
	Description string
	// MaxBytesPerSecond shall be the maximum bytes per second that a connection
	// can support.
	MaxBytesPerSecond int64
	// MaxIOPS shall be the maximum IOs per second that the connection shall
	// allow for the selected access protocol.
	MaxIOPS int
}

IOConnectivityLineOfService is used to specify the characteristics of storage connectivity.

func GetIOConnectivityLineOfService 

func GetIOConnectivityLineOfService(c common.Client, uri string) (*IOConnectivityLineOfService, error)

GetIOConnectivityLineOfService will get a IOConnectivityLineOfService instance from the service.

func ListReferencedIOConnectivityLineOfServices 

func ListReferencedIOConnectivityLineOfServices(c common.Client, link string) ([]*IOConnectivityLineOfService, error)

ListReferencedIOConnectivityLineOfServices gets the collection of IOConnectivityLineOfService from a provided reference.

type IOConnectivityLoSCapabilities 

type IOConnectivityLoSCapabilities struct {
	common.Entity

	// ODataContext is the odata context.
	ODataContext string `json:"@odata.context"`
	// ODataType is the odata type.
	ODataType string `json:"@odata.type"`
	// Description provides a description of this resource.
	Description string
	// Identifier shall be unique within the managed ecosystem.
	Identifier common.Identifier
	// MaxSupportedBytesPerSecond shall be the maximum bytes per second that a
	// connection can support.
	MaxSupportedBytesPerSecond int64
	// MaxSupportedIOPS shall be the maximum IOPS that a connection can support.
	MaxSupportedIOPS int
	// SupportedAccessProtocols is Access protocols supported by this service
	// option. NOTE: SMB+NFS* requires that SMB and at least one of NFSv3 or
	// NFXv4 are also selected, (i.e. {'SMB', 'NFSv4', 'SMB+NFS*'}).
	SupportedAccessProtocols []common.Protocol
	// SupportedLinesOfService shall contain known and
	// supported IOConnectivityLinesOfService.
	SupportedLinesOfService []IOConnectivityLineOfService
	// SupportedLinesOfServiceCount is the number of IOConnectivityLineOfServices.
	SupportedLinesOfServiceCount int `json:"SupportedLinesOfService@odata.count"`
	// contains filtered or unexported fields
}

IOConnectivityLoSCapabilities describes capabilities of the system to support various IO Connectivity service options.

func GetIOConnectivityLoSCapabilities 

func GetIOConnectivityLoSCapabilities(c common.Client, uri string) (*IOConnectivityLoSCapabilities, error)

GetIOConnectivityLoSCapabilities will get a IOConnectivityLoSCapabilities instance from the service.

func ListReferencedIOConnectivityLoSCapabilitiess 

func ListReferencedIOConnectivityLoSCapabilitiess(c common.Client, link string) ([]*IOConnectivityLoSCapabilities, error)

ListReferencedIOConnectivityLoSCapabilitiess gets the collection of IOConnectivityLoSCapabilities from a provided reference.

func (*IOConnectivityLoSCapabilities) UnmarshalJSON added in v0.5.0 

func (ioconnectivityloscapabilities *IOConnectivityLoSCapabilities) UnmarshalJSON(b []byte) error

UnmarshalJSON unmarshals a IOConnectivityLoSCapabilities object from the raw JSON.

func (*IOConnectivityLoSCapabilities) Update added in v0.5.0 

func (ioconnectivityloscapabilities *IOConnectivityLoSCapabilities) Update() error

Update commits updates to this object's properties to the running system.

type IOPerformanceLineOfService 

type IOPerformanceLineOfService struct {
	common.Entity

	// ODataContext is the odata context.
	ODataContext string `json:"@odata.context"`
	// ODataType is the odata type.
	ODataType string `json:"@odata.type"`
	// AverageIOOperationLatencyMicroseconds shall be the expected average IO
	// latency in microseconds calculated over sample periods (see
	// SamplePeriodSeconds).
	AverageIOOperationLatencyMicroseconds int
	// Description provides a description of this resource.
	Description string
	// IOOperationsPerSecondIsLimited means if true, the system should not allow
	// IOPS to exceed MaxIoOperationsPerSecondPerTerabyte * VolumeSize.
	// Otherwise, the system shall not enforce a limit. The default value
	// for this property is false.
	IOOperationsPerSecondIsLimited bool
	// IOWorkload shall be a description of the expected
	// workload. The workload provides the context in which the values of
	// MaxIOOperationsPerSecondPerTerabyte and
	// AverageIOOperationLatencyMicroseconds are expected to be achievable.
	IOWorkload IOWorkload
	// MaxIOOperationsPerSecondPerTerabyte shall be the amount
	// of IOPS a volume of a given committed size in Terabytes can support.
	// This IOPS density value is useful as a metric that is independent of
	// capacity. Cost is a function of this value and the
	// AverageIOOperationLatencyMicroseconds.
	MaxIOOperationsPerSecondPerTerabyte int
	// SamplePeriod shall be an ISO 8601 duration specifying the
	// sampling period over which average values are calculated.
	SamplePeriod string
}

IOPerformanceLineOfService is used to define a service option related to IO performance.

func GetIOPerformanceLineOfService 

func GetIOPerformanceLineOfService(c common.Client, uri string) (*IOPerformanceLineOfService, error)

GetIOPerformanceLineOfService will get a IOPerformanceLineOfService instance from the service.

func ListReferencedIOPerformanceLineOfServices 

func ListReferencedIOPerformanceLineOfServices(c common.Client, link string) ([]*IOPerformanceLineOfService, error)

ListReferencedIOPerformanceLineOfServices gets the collection of IOPerformanceLineOfService from a provided reference.

type IOPerformanceLoSCapabilities 

type IOPerformanceLoSCapabilities struct {
	common.Entity

	// ODataContext is the odata context.
	ODataContext string `json:"@odata.context"`
	// ODataType is the odata type.
	ODataType string `json:"@odata.type"`
	// Description provides a description of this resource.
	Description string
	// IOLimitingIsSupported if true, the system should limit IOPS to
	// MaxIOOperationsPerSecondPerTerabyte * (Volume Size in Terabytes).
	// Otherwise, the system shall not enforce a limit. The default value for
	// this property is false.
	IOLimitingIsSupported bool
	// Identifier shall be unique within the managed ecosystem.
	Identifier common.Identifier
	// MaxSamplePeriod shall be an ISO 8601 duration specifying the maximum
	// sampling period over which average values are calculated.
	MaxSamplePeriod string
	// MinSamplePeriod shall be an ISO 8601 duration specifying the minimum
	// sampling period over which average values are calculated.
	MinSamplePeriod string
	// MinSupportedIoOperationLatencyMicroseconds shall be the minimum supported
	// average IO latency in microseconds calculated over the SamplePeriod
	MinSupportedIoOperationLatencyMicroseconds int
	// SupportedIOWorkloads shall be a collection of supported workloads.
	SupportedIOWorkloads []IOWorkload
	// SupportedLinesOfService shall be a collection of supported IO performance
	// service options.
	SupportedLinesOfService []IOPerformanceLineOfService
	// SupportedLinesOfServiceCount is
	SupportedLinesOfServiceCount int `json:"SupportedLinesOfService@odata.count"`
	// contains filtered or unexported fields
}

IOPerformanceLoSCapabilities shall describe the capabilities of the system to support various IO performance service options.

func GetIOPerformanceLoSCapabilities 

func GetIOPerformanceLoSCapabilities(c common.Client, uri string) (*IOPerformanceLoSCapabilities, error)

GetIOPerformanceLoSCapabilities will get a IOPerformanceLoSCapabilities instance from the service.

func ListReferencedIOPerformanceLoSCapabilitiess 

func ListReferencedIOPerformanceLoSCapabilitiess(c common.Client, link string) ([]*IOPerformanceLoSCapabilities, error)

ListReferencedIOPerformanceLoSCapabilitiess gets the collection of IOPerformanceLoSCapabilities from a provided reference.

func (*IOPerformanceLoSCapabilities) UnmarshalJSON added in v0.5.0 

func (ioperformanceloscapabilities *IOPerformanceLoSCapabilities) UnmarshalJSON(b []byte) error

UnmarshalJSON unmarshals a IOPerformanceLoSCapabilities object from the raw JSON.

func (*IOPerformanceLoSCapabilities) Update added in v0.5.0 

func (ioperformanceloscapabilities *IOPerformanceLoSCapabilities) Update() error

Update commits updates to this object's properties to the running system.

type IOStatistics 

type IOStatistics struct {
	// NonIORequestTime shall be an ISO 8601 conformant duration describing the
	// time that the resource is busy processing non IO requests.
	NonIORequestTime string
	// NonIORequests shall represent the total count from the time of last reset
	// or wrap of non IO requests.
	NonIORequests int64
	// ReadHitIORequests shall represent the total count from the time of last
	// reset or wrap of read IO requests satisfied from memory.
	ReadHitIORequests int64
	// ReadIOKiBytes shall represent the total number of kibibytes read from the
	// time of last reset or wrap.
	ReadIOKiBytes int64
	// ReadIORequestTime shall be an ISO 8601 conformant duration describing the
	// time that the resource is busy processing read requests.
	ReadIORequestTime string
	// ReadIORequests shall represent the total count from the time of last
	// reset or wrap of read IO requests satisfied from either media or memory
	// (i.e. from a storage device or from a cache).
	ReadIORequests int64
	// WriteHitIORequests shall represent the total count from the time of last
	// reset or wrap of write IO requests coalesced into memory.
	WriteHitIORequests int64
	// WriteIOKiBytes shall represent the total number of kibibytes written from
	// the time of last reset or wrap.
	WriteIOKiBytes int64
	// WriteIORequestTime shall be an ISO 8601 conformant duration describing
	// the time that the resource is busy processing write requests.
	WriteIORequestTime string
	// WriteIORequests shall represent the total count from the time of last
	// reset or wrap of write IO requests.
	WriteIORequests int64
}

IOStatistics is used to represent the IO statistics of the requested object.

type IOWorkload 

type IOWorkload struct {
	// Components shall be an array of IO workload component
	// descriptions.
	Components []IOWorkloadComponent
}

IOWorkload is used to describe an IO Workload.

type IOWorkloadComponent 

type IOWorkloadComponent struct {
	// AverageIOBytes shall be the expected average I/O size.
	AverageIOBytes int
	// Duration is The value of each entry shall be an ISO 8601 duration that
	// shall specify the expected length of time that this component is
	// applied to the workload. This attribute shall be specified if a
	// schedule is specified and otherwise shall not be specified.
	Duration string
	// IOAccessPattern is The enumeration literal shall be the expected
	// access pattern.
	IOAccessPattern IOAccessPattern
	// PercentOfData shall be the expected percent of the data
	// referenced by the workload that is covered by this component.
	PercentOfData int
	// PercentOfIOPS shall be the expected percent of the total
	// IOPS for this workload that is covered by this component
	PercentOfIOPS int
	// Schedule shall specifies when this workload component is
	// applied to the overall workload.
	Schedule common.Schedule
}

IOWorkloadComponent is used to describe a component of an IO workload.

type InitializeType 

type InitializeType string

InitializeType is 

const (

	// FastInitializeType The volume is prepared for use quickly, typically
	// by erasing just the beginning and end of the space so that
	// partitioning can be performed.
	FastInitializeType InitializeType = "Fast"
	// SlowInitializeType The volume is prepared for use slowly, typically by
	// completely erasing the volume.
	SlowInitializeType InitializeType = "Slow"
)

type KeySize 

type KeySize string

KeySize shall specify Key sizes in a symmetric encryption algorithm, (see NIST SP 800-57 part 1 ( http:/csrc.nist.gov/publications/nistpubs/800-57/sp800-57_part1_rev3_general.pdf) 

const (
	// Bits0KeySize specifies that there is no key.
	Bits0KeySize KeySize = "Bits_0"
	// Bits112KeySize specifies a 3DES 112 bit key.
	Bits112KeySize KeySize = "Bits_112"
	// Bits128KeySize specifies an AES 128 bit key.
	Bits128KeySize KeySize = "Bits_128"
	// Bits192KeySize specifies an AES 192 bit key.
	Bits192KeySize KeySize = "Bits_192"
	// Bits256KeySize specifies an AES 256 bit key.
	Bits256KeySize KeySize = "Bits_256"
)

type MappedVolume 

type MappedVolume struct {
	// LogicalUnitNumber is the value is a SCSI Logical Unit Number for the Volume.
	LogicalUnitNumber int
	// Volume shall reference a mapped Volume.
	Volume common.Link
}

MappedVolume is an exposed volume mapping.

type ProvisioningPolicy 

type ProvisioningPolicy string

ProvisioningPolicy is used to specify space provisioning policy. 

const (
	// FixedProvisioningPolicy shall be fully allocated.
	FixedProvisioningPolicy ProvisioningPolicy = "Fixed"
	// ThinProvisioningPolicy specifies storage may be over allocated.
	ThinProvisioningPolicy ProvisioningPolicy = "Thin"
)

type QuotaType 

type QuotaType string

QuotaType shall indicate whether quotas are enabled and enforced by this file share. If QuotaType is present, a value of Soft shall mean that quotas are enabled but not enforced, and a value of Hard shall mean that quotas are enabled and enforced. 

const (
	// SoftQuotaType shall indicate that quotas are enabled but not enforced.
	SoftQuotaType QuotaType = "Soft"
	// HardQuotaType shall indicate that quotas are enabled and enforced.
	HardQuotaType QuotaType = "Hard"
)

type RAIDType 

type RAIDType string

RAIDType is 

const (

	// RAID0RAIDType A placement policy where consecutive logical blocks of
	// data are uniformly distributed across a set of independent storage
	// devices without offering any form of redundancy. This is commonly
	// referred to as data striping. This form of RAID will encounter data
	// loss with the failure of any storage device in the set.
	RAID0RAIDType RAIDType = "RAID0"
	// RAID1RAIDType A placement policy where each logical block of data is
	// stored on more than one independent storage device. This is commonly
	// referred to as mirroring. Data stored using this form of RAID is able
	// to survive a single storage device failure without data loss.
	RAID1RAIDType RAIDType = "RAID1"
	// RAID3RAIDType A placement policy using parity-based protection where
	// logical bytes of data are uniformly distributed across a set of
	// independent storage devices and where the parity is stored on a
	// dedicated independent storage device. Data stored using this form of
	// RAID is able to survive a single storage device failure without data
	// loss. If the storage devices use rotating media, they are assumed to
	// be rotationally synchronized, and the data stripe size should be no
	// larger than the exported block size.
	RAID3RAIDType RAIDType = "RAID3"
	// RAID4RAIDType A placement policy using parity-based protection where
	// logical blocks of data are uniformly distributed across a set of
	// independent storage devices and where the parity is stored on a
	// dedicated independent storage device. Data stored using this form of
	// RAID is able to survive a single storage device failure without data
	// loss.
	RAID4RAIDType RAIDType = "RAID4"
	// RAID5RAIDType A placement policy using parity-based protection for
	// storing stripes of 'n' logical blocks of data and one logical block of
	// parity across a set of 'n+1' independent storage devices where the
	// parity and data blocks are interleaved across the storage devices.
	// Data stored using this form of RAID is able to survive a single
	// storage device failure without data loss.
	RAID5RAIDType RAIDType = "RAID5"
	// RAID6RAIDType A placement policy using parity-based protection for
	// storing stripes of 'n' logical blocks of data and two logical blocks
	// of independent parity across a set of 'n+2' independent storage
	// devices where the parity and data blocks are interleaved across the
	// storage devices. Data stored using this form of RAID is able to
	// survive any two independent storage device failures without data loss.
	RAID6RAIDType RAIDType = "RAID6"
	// RAID10RAIDType A placement policy that creates a striped device (RAID
	// 0) over a set of mirrored devices (RAID 1). This is commonly referred
	// to as RAID 1/0. Data stored using this form of RAID is able to survive
	// storage device failures in each RAID 1 set without data loss.
	RAID10RAIDType RAIDType = "RAID10"
	// RAID01RAIDType A data placement policy that creates a mirrored device
	// (RAID 1) over a set of striped devices (RAID 0). This is commonly
	// referred to as RAID 0+1 or RAID 0/1. Data stored using this form of
	// RAID is able to survive a single RAID 0 data set failure without data
	// loss.
	RAID01RAIDType RAIDType = "RAID01"
	// RAID6TPRAIDType A placement policy that uses parity-based protection
	// for storing stripes of 'n' logical blocks of data and three logical
	// blocks of independent parity across a set of 'n+3' independent storage
	// devices where the parity and data blocks are interleaved across the
	// storage devices. This is commonly referred to as Triple Parity RAID.
	// Data stored using this form of RAID is able to survive any three
	// independent storage device failures without data loss.
	RAID6TPRAIDType RAIDType = "RAID6TP"
	// RAID1ERAIDType A placement policy that uses a form of mirroring
	// implemented over a set of independent storage devices where logical
	// blocks are duplicated on a pair of independent storage devices so that
	// data is uniformly distributed across the storage devices. This is
	// commonly referred to as RAID 1 Enhanced. Data stored using this form
	// of RAID is able to survive a single storage device failure without
	// data loss.
	RAID1ERAIDType RAIDType = "RAID1E"
	// RAID50RAIDType A placement policy that uses a RAID 0 stripe set over
	// two or more RAID 5 sets of independent storage devices. Data stored
	// using this form of RAID is able to survive a single storage device
	// failure within each RAID 5 set without data loss.
	RAID50RAIDType RAIDType = "RAID50"
	// RAID60RAIDType A placement policy that uses a RAID 0 stripe set over
	// two or more RAID 6 sets of independent storage devices. Data stored
	// using this form of RAID is able to survive two device failures within
	// each RAID 6 set without data loss.
	RAID60RAIDType RAIDType = "RAID60"
	// RAID00RAIDType A placement policy that creates a RAID 0 stripe set
	// over two or more RAID 0 sets. This is commonly referred to as RAID
	// 0+0. This form of data layout is not fault tolerant; if any storage
	// device fails there will be data loss.
	RAID00RAIDType RAIDType = "RAID00"
	// RAID10ERAIDType A placement policy that uses a RAID 0 stripe set over
	// two or more RAID 10 sets. This is commonly referred to as Enhanced
	// RAID 10. Data stored using this form of RAID is able to survive a
	// single device failure within each nested RAID 1 set without data loss.
	RAID10ERAIDType RAIDType = "RAID10E"
	// RAID1TripleRAIDType A placement policy where each logical block of
	// data is mirrored three times across a set of three independent storage
	// devices. This is commonly referred to as three-way mirroring. This
	// form of RAID can survive two device failures without data loss.
	RAID1TripleRAIDType RAIDType = "RAID1Triple"
	// RAID10TripleRAIDType A placement policy that uses a striped device
	// (RAID 0) over a set of triple mirrored devices (RAID 1Triple). This
	// form of RAID can survive up to two failures in each triple mirror set
	// without data loss.
	RAID10TripleRAIDType RAIDType = "RAID10Triple"
)

type ReadCachePolicyType added in v0.5.0 

type ReadCachePolicyType string

ReadCachePolicyType is the type of read cache policy. 

const (

	// ReadAheadReadCachePolicyType A caching technique in which the
	// controller pre-fetches data anticipating future read requests.
	ReadAheadReadCachePolicyType ReadCachePolicyType = "ReadAhead"
	// AdaptiveReadAheadReadCachePolicyType A caching technique in which the
	// controller dynamically determines whether to pre-fetch data
	// anticipating future read requests, based on previous cache hit ratio.
	AdaptiveReadAheadReadCachePolicyType ReadCachePolicyType = "AdaptiveReadAhead"
	// OffReadCachePolicyType The read cache is disabled.
	OffReadCachePolicyType ReadCachePolicyType = "Off"
)

type RecoveryAccessScope 

type RecoveryAccessScope string

RecoveryAccessScope shall represent the relative time required to make a replica available as a source. 

const (
	// OnlineActiveRecoveryAccessScope shall be instantaneous.
	OnlineActiveRecoveryAccessScope RecoveryAccessScope = "OnlineActive"
	// OnlinePassiveRecoveryAccessScope shall be consistent with switching
	// access to a different path the same front-end interconnect. A restore
	// step shall not be required.
	OnlinePassiveRecoveryAccessScope RecoveryAccessScope = "OnlinePassive"
	// NearlineRecoveryAccessScope shall be consistent with switching access
	// to a different path through a different front-end interconnection
	// infrastructure. Some inconsistency may occur. A restore step may be
	// required before recovery can commence.
	NearlineRecoveryAccessScope RecoveryAccessScope = "Nearline"
	// OfflineRecoveryAccessScope Access to a replica may take a significant
	// amount of time. No direct connection to the replica is assumed. Some
	// inconsistency loss may occur. A restore step is likely to be
	// required.
	OfflineRecoveryAccessScope RecoveryAccessScope = "Offline"
)

type ReplicaInfo 

type ReplicaInfo struct {
	// ConsistencyEnabled is If true, consistency shall be enabled across the
	// source and its associated target replica(s). The default value for
	// this property is false.
	ConsistencyEnabled bool
	// ConsistencyState is The ConsistencyState enumeration literal shall
	// indicate the current state of consistency.
	ConsistencyState ConsistencyState
	// ConsistencyStatus is The ConsistencyStatus enumeration literal shall
	// specify the current status of consistency. Consistency may have been
	// disabled or is experiencing an error condition.
	ConsistencyStatus ConsistencyStatus
	// ConsistencyType is used by the source and its associated target group.
	ConsistencyType ConsistencyType

	// FailedCopyStopsHostIO is If true, the storage array shall stop
	// receiving data to the source element if copying to a remote element
	// fails. The default value for this property is false.
	FailedCopyStopsHostIO bool
	// PercentSynced is Specifies the percent of the work completed to reach
	// synchronization. Shall not be instantiated if implementation is not
	// capable of providing this information.  If related to a group, then
	// PercentSynced shall be an average of the PercentSynced across all
	// members of the group.
	PercentSynced int

	// ReplicaPriority shall specify the priority
	// of background copy engine I/O to be managed relative to host I/O
	// operations during a sequential background copy operation.
	ReplicaPriority ReplicaPriority
	// ReplicaProgressStatus is The ReplicaProgressStatus enumeration literal
	// shall specify the status of the session with respect to Replication
	// activity.
	ReplicaProgressStatus ReplicaProgressStatus
	// ReplicaReadOnlyAccess shall specify whether
	// the source, the target, or both elements are read only to the host.
	ReplicaReadOnlyAccess ReplicaReadOnlyAccess
	// ReplicaRecoveryMode shall specify whether
	// the copy operation continues after a broken link is restored.
	ReplicaRecoveryMode ReplicaRecoveryMode
	// ReplicaSkewBytes is Applies to Adaptive mode and it describes maximum
	// number of bytes the SyncedElement (target) can be out of sync. If the
	// number of out-of-sync bytes exceeds the skew value, ReplicaUpdateMode
	// shall be switched to synchronous.
	ReplicaSkewBytes int64
	// ReplicaState is The ReplicaState enumeration literal shall specify the
	// state of the relationship with respect to Replication activity.
	ReplicaState ReplicaState
	// ReplicaType is The ReplicaType enumeration literal shall describe the
	// intended outcome of the replication.
	ReplicaType ReplicaType
	// ReplicaUpdateMode shall specify whether the
	// target elements will be updated synchronously or asynchronously.
	ReplicaUpdateMode ReplicaUpdateMode
	// RequestedReplicaState is The last requested or desired state for the
	// relationship. The actual state of the relationship shall be
	// represented by ReplicaState. When RequestedState reaches the requested
	// state, this property shall be null.
	RequestedReplicaState ReplicaState
	// SyncMaintained is If true, Synchronization shall be maintained. The
	// default value for this property is false.
	SyncMaintained bool
	// UndiscoveredElement shall specify whether
	// the source, the target, or both elements involved in a copy operation
	// are undiscovered. An element is considered undiscovered if its object
	// model is not known to the service performing the copy operation.
	UndiscoveredElement UndiscoveredElement
	// WhenActivated shall be an ISO 8601 conformant time of day
	// that specifies when the point-in-time copy was taken or when the
	// replication relationship is activated, reactivated, resumed or re-
	// established. This property shall be null if the implementation is not
	// capable of providing this information.
	WhenActivated string
	// WhenDeactivated shall be an ISO 8601 conformant time of
	// day that specifies when the replication relationship is deactivated.
	// Do not instantiate this property if implementation is not capable of
	// providing this information.
	WhenDeactivated string
	// WhenEstablished shall be an ISO 8601 conformant time of
	// day that specifies when the replication relationship is established.
	// Do not instantiate this property if implementation is not capable of
	// providing this information.
	WhenEstablished string
	// WhenSuspended shall be an ISO 8601 conformant time of day
	// that specifies when the replication relationship is suspended. Do not
	// instantiate this property if implementation is not capable of
	// providing this information.
	WhenSuspended string
	// WhenSynced shall be an ISO 8601 conformant time of day
	// that specifies when the elements were synchronized.
	WhenSynced string
	// WhenSynchronized shall be an ISO 8601 conformant time of
	// day that specifies when the replication relationship is synchronized.
	// Do not instantiate this property if implementation is not capable of
	// providing this information.
	WhenSynchronized string
	// contains filtered or unexported fields
}

ReplicaInfo shall define the characteristics of a replica.

func (*ReplicaInfo) UnmarshalJSON 

func (replicainfo *ReplicaInfo) UnmarshalJSON(b []byte) error

UnmarshalJSON unmarshals a ReplicaInfo object from the raw JSON.

type ReplicaPriority 

type ReplicaPriority string

ReplicaPriority is used to specify the priority of background copy engine I/O relative to host I/O operations during a sequential background copy operation. 

const (
	// LowReplicaPriority shall have a lower priority than host I/O.
	LowReplicaPriority ReplicaPriority = "Low"
	// SameReplicaPriority shall have the same priority as host I/O.
	SameReplicaPriority ReplicaPriority = "Same"
	// HighReplicaPriority shall have a higher priority than host I/O.
	HighReplicaPriority ReplicaPriority = "High"
	// UrgentReplicaPriority shall be performed as soon as possible.
	UrgentReplicaPriority ReplicaPriority = "Urgent"
)

type ReplicaProgressStatus 

type ReplicaProgressStatus string

ReplicaProgressStatus is used to describe the status of the session with respect to Replication activity. 

const (
	// CompletedReplicaProgressStatus shall indicate that the request is
	// completed. Data flow is idle.
	CompletedReplicaProgressStatus ReplicaProgressStatus = "Completed"
	// DormantReplicaProgressStatus shall indicate that the data flow is
	// inactive, suspended or quiesced.
	DormantReplicaProgressStatus ReplicaProgressStatus = "Dormant"
	// InitializingReplicaProgressStatus shall indicate that replication is
	// in the process of establishing source/replica relationship and the
	// data flow has not started.
	InitializingReplicaProgressStatus ReplicaProgressStatus = "Initializing"
	// PreparingReplicaProgressStatus shall indicate that replication has
	// preparation in progress.
	PreparingReplicaProgressStatus ReplicaProgressStatus = "Preparing"
	// SynchronizingReplicaProgressStatus shall indicate that replication has
	// synchronization in progress.
	SynchronizingReplicaProgressStatus ReplicaProgressStatus = "Synchronizing"
	// ResyncingReplicaProgressStatus shall indicate that replication has
	// resynchronization in progress.
	ResyncingReplicaProgressStatus ReplicaProgressStatus = "Resyncing"
	// RestoringReplicaProgressStatus shall indicate that replication has a
	// restore in progress.
	RestoringReplicaProgressStatus ReplicaProgressStatus = "Restoring"
	// FracturingReplicaProgressStatus shall indicate that replication has a
	// fracture in progress.
	FracturingReplicaProgressStatus ReplicaProgressStatus = "Fracturing"
	// SplittingReplicaProgressStatus shall indicate that replication has a
	// split in progress.
	SplittingReplicaProgressStatus ReplicaProgressStatus = "Splitting"
	// FailingOverReplicaProgressStatus shall indicate that replication is in
	// the process of switching source and target.
	FailingOverReplicaProgressStatus ReplicaProgressStatus = "FailingOver"
	// FailingBackReplicaProgressStatus shall indicate that replication is
	// undoing the result of failover.
	FailingBackReplicaProgressStatus ReplicaProgressStatus = "FailingBack"
	// DetachingReplicaProgressStatus shall indicate that replication has a
	// detach in progress.
	DetachingReplicaProgressStatus ReplicaProgressStatus = "Detaching"
	// AbortingReplicaProgressStatus shall indicate that replication has an
	// abort in progress.
	AbortingReplicaProgressStatus ReplicaProgressStatus = "Aborting"
	// MixedReplicaProgressStatus shall indicate that replication status is
	// mixed across element pairs in a replication group. Generally, the
	// individual statuses need to be examined.
	MixedReplicaProgressStatus ReplicaProgressStatus = "Mixed"
	// SuspendingReplicaProgressStatus shall indicate that replication has a
	// copy operation in the process of being suspended.
	SuspendingReplicaProgressStatus ReplicaProgressStatus = "Suspending"
	// RequiresFractureReplicaProgressStatus shall indicate that the
	// requested operation has completed, however, the synchronization
	// relationship needs to be fractured before further copy operations can
	// be issued.
	RequiresFractureReplicaProgressStatus ReplicaProgressStatus = "RequiresFracture"
	// RequiresResyncReplicaProgressStatus shall indicate that the requested
	// operation has completed, however, the synchronization relationship
	// needs to be resynced before further copy operations can be issued.
	RequiresResyncReplicaProgressStatus ReplicaProgressStatus = "RequiresResync"
	// RequiresActivateReplicaProgressStatus shall indicate that the
	// requested operation has completed, however, the synchronization
	// relationship needs to be activated before further copy operations can
	// be issued.
	RequiresActivateReplicaProgressStatus ReplicaProgressStatus = "RequiresActivate"
	// PendingReplicaProgressStatus shall indicate that the flow of data has
	// stopped momentarily due to limited bandwidth or a busy system.
	PendingReplicaProgressStatus ReplicaProgressStatus = "Pending"
	// RequiresDetachReplicaProgressStatus shall indicate that the requested
	// operation has completed, however, the synchronization relationship
	// needs to be detached before further copy operations can be issued.
	RequiresDetachReplicaProgressStatus ReplicaProgressStatus = "RequiresDetach"
	// TerminatingReplicaProgressStatus shall indicate that the replication
	// relationship is in the process of terminating.
	TerminatingReplicaProgressStatus ReplicaProgressStatus = "Terminating"
	// RequiresSplitReplicaProgressStatus shall indicate that the requested
	// operation has completed, however, the synchronization relationship
	// needs to be split before further copy operations can be issued.
	RequiresSplitReplicaProgressStatus ReplicaProgressStatus = "RequiresSplit"
	// RequiresResumeReplicaProgressStatus shall indicate that the requested
	// operation has completed, however, the synchronization relationship
	// needs to be resumed before further copy operations can be issued.
	RequiresResumeReplicaProgressStatus ReplicaProgressStatus = "RequiresResume"
)

type ReplicaReadOnlyAccess 

type ReplicaReadOnlyAccess string

ReplicaReadOnlyAccess is used to specify whether the source, the target, or both elements are read-only to the host. 

const (
	// SourceElementReplicaReadOnlyAccess shall be read-only to the host.
	SourceElementReplicaReadOnlyAccess ReplicaReadOnlyAccess = "SourceElement"
	// ReplicaElementReplicaReadOnlyAccess shall be read-only to the host.
	ReplicaElementReplicaReadOnlyAccess ReplicaReadOnlyAccess = "ReplicaElement"
	// BothReplicaReadOnlyAccess shall be read only to the host.
	BothReplicaReadOnlyAccess ReplicaReadOnlyAccess = "Both"
)

type ReplicaRecoveryMode 

type ReplicaRecoveryMode string

ReplicaRecoveryMode is used to specify whether the copy operation continues after a broken link is restored. 

const (
	// AutomaticReplicaRecoveryMode shall resume automatically.
	AutomaticReplicaRecoveryMode ReplicaRecoveryMode = "Automatic"
	// ManualReplicaRecoveryMode shall be set to Suspended after the link is
	// restored. It is required to issue the Resume operation to continue.
	ManualReplicaRecoveryMode ReplicaRecoveryMode = "Manual"
)

type ReplicaRequest 

type ReplicaRequest struct {
	// ReplicaName shall be the names of the replica.
	ReplicaName string
	// ReplicaSource shall reference a resource to be
	// replicated.
	ReplicaSource common.Link
}

ReplicaRequest is a request for a replica.

type ReplicaRole 

type ReplicaRole string

ReplicaRole is used to specify whether the resource is a source of replication or the target of replication. 

const (
	// SourceReplicaRole shall indicate a source element.
	SourceReplicaRole ReplicaRole = "Source"
	// TargetReplicaRole shall indicate target element.
	TargetReplicaRole ReplicaRole = "Target"
)

type ReplicaState 

type ReplicaState string

ReplicaState is used to describe the state of the relationship with respect to Replication activity. 

const (
	// InitializedReplicaState shall indicate that the link to enable
	// replication is established and source/replica elements are associated,
	// but the data flow has not started.
	InitializedReplicaState ReplicaState = "Initialized"
	// UnsynchronizedReplicaState shall indicate that not all the source
	// element data has been copied to the target element.
	UnsynchronizedReplicaState ReplicaState = "Unsynchronized"
	// SynchronizedReplicaState shall indicate that for Mirror, Snapshot, or
	// Clone replication, the target represents a copy of the source.
	SynchronizedReplicaState ReplicaState = "Synchronized"
	// BrokenReplicaState shall indicate that the relationship is non-
	// functional due to errors in the source, the target, the path between
	// the two or space constraints.
	BrokenReplicaState ReplicaState = "Broken"
	// FracturedReplicaState shall indicate that the Target is split from the
	// source. The target may not be consistent.
	FracturedReplicaState ReplicaState = "Fractured"
	// SplitReplicaState shall indicate that the target element was
	// gracefully (or systematically) split from its source element --
	// consistency shall be guaranteed.
	SplitReplicaState ReplicaState = "Split"
	// InactiveReplicaState shall indicate that data flow has stopped, writes
	// to source element shall not be sent to target element.
	InactiveReplicaState ReplicaState = "Inactive"
	// SuspendedReplicaState shall indicate that the data flow between the
	// source and target elements has stopped. Writes to source element shall
	// be held until the relationship is Resumed.
	SuspendedReplicaState ReplicaState = "Suspended"
	// FailedoverReplicaState shall indicate that the reads and writes are
	// sent to the target element. The source element may not be reachable.
	FailedoverReplicaState ReplicaState = "Failedover"
	// PreparedReplicaState shall indicate that initialization is completed,
	// however, the data flow has not started.
	PreparedReplicaState ReplicaState = "Prepared"
	// AbortedReplicaState shall indicate that the copy operation is aborted
	// with the Abort operation. The Resync Replica operation can be used to
	// restart the copy operation.
	AbortedReplicaState ReplicaState = "Aborted"
	// SkewedReplicaState shall indicate that the target has been modified
	// and is no longer synchronized with the source element or the point-in-
	// time view.
	SkewedReplicaState ReplicaState = "Skewed"
	// MixedReplicaState shall indicate the ReplicaState of
	// GroupSynchronized. The value indicates the StorageSynchronized
	// relationships of the elements in the group have different ReplicaState
	// values.
	MixedReplicaState ReplicaState = "Mixed"
	// PartitionedReplicaState shall indicate that the state of replication
	// relationship can not be determined, for example, due to a connection
	// problem.
	PartitionedReplicaState ReplicaState = "Partitioned"
	// InvalidReplicaState shall indicate that the storage server is unable
	// to determine the state of the replication relationship, for example,
	// after the connection is restored; however, either source or target
	// elements have an unknown status.
	InvalidReplicaState ReplicaState = "Invalid"
	// RestoredReplicaState shall indicate that the source element was
	// restored from the target element.
	RestoredReplicaState ReplicaState = "Restored"
)

type ReplicaType 

type ReplicaType string

ReplicaType is used to specify the intended outcome of the replication. 

const (
	// MirrorReplicaType shall indicate that replication shall create and
	// maintain a copy of the source.
	MirrorReplicaType ReplicaType = "Mirror"
	// SnapshotReplicaType shall indicate that replication shall create a
	// point in time, virtual copy of the source.
	SnapshotReplicaType ReplicaType = "Snapshot"
	// CloneReplicaType shall indicate that replication shall create a point
	// in time, full copy the source.
	CloneReplicaType ReplicaType = "Clone"
	// TokenizedCloneReplicaType shall indicate that replication shall create
	// a token based clone.
	TokenizedCloneReplicaType ReplicaType = "TokenizedClone"
)

type ReplicaUpdateMode 

type ReplicaUpdateMode string

ReplicaUpdateMode is used to specify whether the target elements will be updated synchronously or asynchronously. 

const (
	// ActiveReplicaUpdateMode shall indicate Active-Active (i.e.
	// bidirectional) synchronous updates.
	ActiveReplicaUpdateMode ReplicaUpdateMode = "Active"
	// SynchronousReplicaUpdateMode shall indicate Synchronous updates.
	SynchronousReplicaUpdateMode ReplicaUpdateMode = "Synchronous"
	// AsynchronousReplicaUpdateMode shall indicate Asynchronous updates.
	AsynchronousReplicaUpdateMode ReplicaUpdateMode = "Asynchronous"
	// AdaptiveReplicaUpdateMode shall indicate that an implementation may
	// switch between synchronous and asynchronous modes.
	AdaptiveReplicaUpdateMode ReplicaUpdateMode = "Adaptive"
)

type SecureChannelProtocol 

type SecureChannelProtocol string

SecureChannelProtocol shall specify types of Secure channel protocols. 

const (
	// NoneSecureChannelProtocol specifies no encryption.
	NoneSecureChannelProtocol SecureChannelProtocol = "None"
	// TLSSecureChannelProtocol specifies Transport
	// Layer Security (TLS), as defined by IETF RFC 5246.
	TLSSecureChannelProtocol SecureChannelProtocol = "TLS"
	// IPsecSecureChannelProtocol specifies Internet
	// Protocol Security (IPsec), as defined by IETF RFC 2401.
	IPsecSecureChannelProtocol SecureChannelProtocol = "IPsec"
	// RPCSECGSSSecureChannelProtocol specifies RPC
	// access to the Generic Security Services Application Programming
	// Interface (GSS-API), as defined by IETF RPC 2203.
	RPCSECGSSSecureChannelProtocol SecureChannelProtocol = "RPCSEC_GSS"
)

type SpareResourceSet 

type SpareResourceSet struct {
	common.Entity

	// ODataContext is the odata context.
	ODataContext string `json:"@odata.context"`
	// ODataType is the odata type.
	ODataType string `json:"@odata.type"`
	// Description provides a description of this resource.
	Description string
	// OnHandLocation is the location where this set of spares is kept.
	OnHandLocation common.Location
	// OnLine indicates if the set is online.
	OnLine bool
	// ResourceType is the type of resources in the set.
	ResourceType string
	// TimeToProvision is the amount of time needed to make an on-hand resource
	// available as a spare.
	TimeToProvision string
	// TimeToReplenish is the amount of time to needed replenish consumed on-hand
	// resources.
	TimeToReplenish string
	// OnHandSparesCount is the number of on hand spares.
	OnHandSparesCount int `json:"OnHandSpares@odata.count"`
	// ReplacementSpareSetsCount is the number of replacement spare sets.
	ReplacementSpareSetsCount int `json:"ReplacementSpareSets@odata.count"`
	// contains filtered or unexported fields
}

SpareResourceSet define a set of spares of a particular type.

func GetSpareResourceSet 

func GetSpareResourceSet(c common.Client, uri string) (*SpareResourceSet, error)

GetSpareResourceSet will get a SpareResourceSet instance from the service.

func ListReferencedSpareResourceSets 

func ListReferencedSpareResourceSets(c common.Client, link string) ([]*SpareResourceSet, error)

ListReferencedSpareResourceSets gets the collection of SpareResourceSet from a provided reference.

func (*SpareResourceSet) ReplacementSpareSets 

func (spareresourceset *SpareResourceSet) ReplacementSpareSets() ([]*SpareResourceSet, error)

ReplacementSpareSets gets other spare sets that can be utilized to replenish this spare set.

func (*SpareResourceSet) UnmarshalJSON 

func (spareresourceset *SpareResourceSet) UnmarshalJSON(b []byte) error

UnmarshalJSON unmarshals a SpareResourceSet object from the raw JSON.

func (*SpareResourceSet) Update added in v0.5.0 

func (spareresourceset *SpareResourceSet) Update() error

Update commits updates to this object's properties to the running system.

type StorageAccessCapability 

type StorageAccessCapability string

StorageAccessCapability is used to describe abilities to read or write storage. 

const (
	// ReadStorageAccessCapability shall indicate that the storage may be
	// read.
	ReadStorageAccessCapability StorageAccessCapability = "Read"
	// WriteStorageAccessCapability shall indicate that the storage may be
	// written multiple times.
	WriteStorageAccessCapability StorageAccessCapability = "Write"
	// WriteOnceStorageAccessCapability shall indicate that the storage may
	// be written only once.
	WriteOnceStorageAccessCapability StorageAccessCapability = "WriteOnce"
	// AppendStorageAccessCapability shall indicate that the storage may be
	// written only to append.
	AppendStorageAccessCapability StorageAccessCapability = "Append"
	// StreamingStorageAccessCapability shall indicate that the storage may
	// be read sequentially.
	StreamingStorageAccessCapability StorageAccessCapability = "Streaming"
	// ExecuteStorageAccessCapability shall indicate that Execute access is
	// allowed by the file share.
	ExecuteStorageAccessCapability StorageAccessCapability = "Execute"
)

type StorageGroup 

type StorageGroup struct {
	common.Entity

	// ODataContext is the odata context.
	ODataContext string `json:"@odata.context"`
	// ODataType is the odata type.
	ODataType string `json:"@odata.type"`
	// AccessState shall describe the access
	// characteristics of this storage group. All associated logical units
	// through all aggregated ports shall share this access state.
	AccessState AccessState
	// AuthenticationMethod is The value of this property must be what kind
	// of authentication that the endpoints in this StorageGroup understands.
	AuthenticationMethod AuthenticationMethod
	// ChapInfo is used by this specific endpoint. For example, if this
	// endpoint represents an initiator, and AuthenticationMethod is CHAP or
	// MutualCHAP, the Credentials fields CHAPUsername and CHAPSecret must be
	// used. If this endpoint represents a target endpoint and
	// AuthenticationMethod is MutualCHAP, then MutualCHAPUsername and
	// MutualCHAPSecret must be used.
	ChapInfo []CHAPInformation
	// ClientEndpointGroups is used to make requests to the storage exposed
	// by this StorageGroup. If null, the implementation may allow access to
	// the storage via any client-side endpoint. If empty, the
	// implementation shall not allow access to the storage via any client-
	// side endpoint.
	ClientEndpointGroups []EndpointGroup
	// ClientEndpointGroups@odata.count is
	ClientEndpointGroupsCount int `json:"ClientEndpointGroups@odata.count"`
	// Description provides a description of this resource.
	Description string
	// Identifier shall be unique within the managed ecosystem.
	Identifier common.Identifier
	// mappedVolumes is an array of mapped volumes managed by this storage
	// group.
	MappedVolumes []MappedVolume
	// MembersAreConsistent shall be set to true if all members are in a
	// consistent state. The default value for this property is false.
	MembersAreConsistent bool
	// ReplicaInfo shall describe the replication relationship between this
	// storage group and a corresponding source storage group.
	ReplicaInfo ReplicaInfo
	// ReplicaTargets shall reference the target replicas that
	// are sourced by this replica.
	// replicaTargets []string
	// ReplicaTargetsCount is number of replica targets.
	ReplicaTargetsCount int `json:"ReplicaTargets@odata.count"`
	// serverEndpointGroups is used to make requests to the storage exposed
	// by this storage group. If null, the implementation may allow access
	// to the storage via any server-side endpoint. If empty, the
	// implementation shall not allow access to the storage via any server-
	// side endpoint.
	// serverEndpointGroups []string
	// ServerEndpointGroupsCount is the number of server endpoints.
	ServerEndpointGroupsCount int `json:"ServerEndpointGroups@odata.count"`
	// Status is the status of this group.
	Status common.Status
	// VolumesCount is the number of volumes.
	VolumesCount int `json:"Volumes@odata.count"`
	// VolumesAreExposed shall be set to true if storage volumes are exposed to
	// the paths defined by the client and server endpoints. The default value
	// for this property is false.
	VolumesAreExposed bool

	// ChildStorageGroupsCount is the number of child storage groups.
	ChildStorageGroupsCount int

	// ParentStorageGroupsCount is the number of parent storage groups.
	ParentStorageGroupsCount int
	// contains filtered or unexported fields
}

StorageGroup is a set of related storage entities (volumes, file systems...) The collection should be useful for managing the storage of a set of related client applications.

func GetStorageGroup 

func GetStorageGroup(c common.Client, uri string) (*StorageGroup, error)

GetStorageGroup will get a StorageGroup instance from the service.

func ListReferencedStorageGroups 

func ListReferencedStorageGroups(c common.Client, link string) ([]*StorageGroup, error)

ListReferencedStorageGroups gets the collection of StorageGroup from a provided reference.

func (*StorageGroup) ChildStorageGroups 

func (storagegroup *StorageGroup) ChildStorageGroups() ([]*StorageGroup, error)

ChildStorageGroups gets child groups of this group.

func (*StorageGroup) ClassOfService 

func (storagegroup *StorageGroup) ClassOfService() (*ClassOfService, error)

ClassOfService gets the ClassOfService that all storage in this StorageGroup conforms to.

func (*StorageGroup) ExposeVolumes 

func (storagegroup *StorageGroup) ExposeVolumes() error

ExposeVolumes exposes the storage of this group via the target endpoints named in the ServerEndpointGroups to the initiator endpoints named in the ClientEndpointGroups. The property VolumesAreExposed shall be set to true when this action is completed.

func (*StorageGroup) HideVolumes 

func (storagegroup *StorageGroup) HideVolumes() error

HideVolumes hides the storage of this group from the initiator endpoints named in the ClientEndpointGroups. The property VolumesAreExposed shall be set to false when this action is completed.

func (*StorageGroup) ParentStorageGroups 

func (storagegroup *StorageGroup) ParentStorageGroups() ([]*StorageGroup, error)

ParentStorageGroups gets parent groups of this group.

func (*StorageGroup) UnmarshalJSON 

func (storagegroup *StorageGroup) UnmarshalJSON(b []byte) error

UnmarshalJSON unmarshals a StorageGroup object from the raw JSON.

func (*StorageGroup) Update added in v0.5.0 

func (storagegroup *StorageGroup) Update() error

Update commits updates to this object's properties to the running system.

type StoragePool 

type StoragePool struct {
	common.Entity

	// ODataContext is the odata context.
	ODataContext string `json:"@odata.context"`
	// ODataType is the odata type.
	ODataType string `json:"@odata.type"`

	// Capacity shall provide an information
	// about the actual utilization of the capacity within this storage pool.
	Capacity Capacity

	// CapacitySourcesCount is the number of capacity sources.
	CapacitySourcesCount int `json:"CapacitySources@odata.count"`

	// Compressed shall contain a boolean indicator if the StoragePool is
	// currently utilizing compression or not.
	Compressed bool
	// Deduplicted shall contain a boolean indicator if the StoragePool is
	// currently utilizing deduplication or not.
	Deduplicated bool

	// Description provides a description of this resource.
	Description string
	// Encrypted shall contain a boolean indicator if the
	// StoragePool is currently utilizing encryption or not.
	Encrypted bool
	// IOStatistics is the value shall represent IO statistics for this
	// StoragePool.
	IOStatistics IOStatistics
	// Identifier shall be unique within the managed ecosystem.
	Identifier common.Identifier
	// LowSpaceWarningThresholdPercents is each time the following value is
	// less than one of the values in the array the
	// LOW_SPACE_THRESHOLD_WARNING event shall be triggered: Across all
	// CapacitySources entries, percent = (SUM(AllocatedBytes) -
	// SUM(ConsumedBytes))/SUM(AllocatedBytes).
	LowSpaceWarningThresholdPercents []int
	// MaxBlockSizeBytes if present, the value is the maximum block size
	// of an allocated resource. If the block size is unknown or if a block
	// concept is not valid (for example, with Memory), this property shall
	// be NULL.
	MaxBlockSizeBytes int64
	// RecoverableCapacitySourceCount is the value of the number of available
	// capacity source resources currently available in the event that an
	// equivalent capacity source resource fails.
	RecoverableCapacitySourceCount int
	// RemainingCapacityPercent if present, this value shall return
	// {[(SUM(AllocatedBytes) - SUM(ConsumedBytes)]/SUM(AllocatedBytes)}*100
	// represented as an integer value.
	RemainingCapacityPercent int
	// Status is the storage pool status.
	Status common.Status

	// DedicatedSpareDrivesCount is the number of drives.
	DedicatedSpareDrivesCount int

	// SpareResourceSetsCount is the number of spare resource sets.
	SpareResourceSetsCount int
	// contains filtered or unexported fields
}

StoragePool is a container of data storage capable of providing capacity conforming to one of its supported classes of service. The storage pool does not support IO to its data storage.

func GetStoragePool 

func GetStoragePool(c common.Client, uri string) (*StoragePool, error)

GetStoragePool will get a StoragePool instance from the service.

func ListReferencedStoragePools 

func ListReferencedStoragePools(c common.Client, link string) ([]*StoragePool, error)

ListReferencedStoragePools gets the collection of StoragePool from a provided reference.

func (*StoragePool) AllocatedPools 

func (storagepool *StoragePool) AllocatedPools() ([]*StoragePool, error)

AllocatedPools gets the storage pools allocated from this storage pool.

func (*StoragePool) AllocatedVolumes 

func (storagepool *StoragePool) AllocatedVolumes() ([]*Volume, error)

AllocatedVolumes gets the volumes allocated from this storage pool.

func (*StoragePool) CapacitySources 

func (storagepool *StoragePool) CapacitySources() ([]*CapacitySource, error)

CapacitySources gets space allocations to this pool.

func (*StoragePool) ClassesOfService 

func (storagepool *StoragePool) ClassesOfService() ([]*ClassOfService, error)

ClassesOfService gets references to all classes of service supported by this storage pool. Capacity allocated from this storage pool shall conform to one of the referenced classes of service.

func (*StoragePool) DedicatedSpareDrives 

func (storagepool *StoragePool) DedicatedSpareDrives() ([]*redfish.Drive, error)

DedicatedSpareDrives gets the Drive entities which are currently assigned as a dedicated spare and are able to support this StoragePool.

func (*StoragePool) DefaultClassOfService 

func (storagepool *StoragePool) DefaultClassOfService() (*ClassOfService, error)

DefaultClassOfService gets the default ClassOfService for this pool.

func (*StoragePool) SpareResourceSets 

func (storagepool *StoragePool) SpareResourceSets() ([]*SpareResourceSet, error)

SpareResourceSets gets resources that may be utilized to replace the capacity provided by a failed resource having a compatible type.

func (*StoragePool) UnmarshalJSON 

func (storagepool *StoragePool) UnmarshalJSON(b []byte) error

UnmarshalJSON unmarshals a StoragePool object from the raw JSON.

func (*StoragePool) Update added in v0.5.0 

func (storagepool *StoragePool) Update() error

Update commits updates to this object's properties to the running system.

type StorageReplicaInfo 

type StorageReplicaInfo struct {
	common.Entity

	// ODataContext is the odata context.
	ODataContext string `json:"@odata.context"`
	// ODataType is the odata type.
	ODataType string `json:"@odata.type"`
	// Description provides a description of this resource.
	Description string
}

StorageReplicaInfo is

func GetStorageReplicaInfo 

func GetStorageReplicaInfo(c common.Client, uri string) (*StorageReplicaInfo, error)

GetStorageReplicaInfo will get a StorageReplicaInfo instance from the service.

func ListReferencedStorageReplicaInfos 

func ListReferencedStorageReplicaInfos(c common.Client, link string) ([]*StorageReplicaInfo, error)

ListReferencedStorageReplicaInfos gets the collection of StorageReplicaInfo from a provided reference.

type StorageService 

type StorageService struct {
	common.Entity

	// ODataContext is
	ODataContext string `json:"@odata.context"`
	// ODataEtag is
	// ODataId is
	// ODataType is
	ODataType string `json:"@odata.type"`
	// Description is a description for this StorageService.
	Description string
	// Identifier identifies this resource. The value shall be
	// unique within the managed ecosystem.
	Identifier common.Identifier
	// RedundancyCount is the Redundancy collection object count.
	RedundancyCount int `json:"Redundancy@odata.count"`
	// SpareResourceSetsCount is the number of SpareResourceSet objects.
	SpareResourceSetsCount int `json:"SpareResourceSets@odata.count"`
	// Status is the StorageService status.
	Status common.Status

	// IOStatistics shall represent IO statistics for this StorageService.
	IOStatistics IOStatistics
	// contains filtered or unexported fields
}

StorageService is a collection of resources that the system can make available to one or more host systems. The collection can contain: block, file, or object storage; local system access points through which the collection is made available; hosts, or host access points to which the collection is made available.

func GetStorageService 

func GetStorageService(c common.Client, uri string) (*StorageService, error)

GetStorageService will get a StorageService instance from the service.

func ListReferencedStorageServices 

func ListReferencedStorageServices(c common.Client, link string) ([]*StorageService, error)

ListReferencedStorageServices gets the collection of StorageService from a provided reference.

func (*StorageService) ClassesOfService 

func (storageservice *StorageService) ClassesOfService() ([]*ClassOfService, error)

ClassesOfService gets the storage service's classes of service.

func (*StorageService) DataProtectionLoSCapabilities 

func (storageservice *StorageService) DataProtectionLoSCapabilities() (*DataProtectionLoSCapabilities, error)

DataProtectionLoSCapabilities gets the storage service's data protection capabilities.

func (*StorageService) DataSecurityLoSCapabilities 

func (storageservice *StorageService) DataSecurityLoSCapabilities() (*DataSecurityLoSCapabilities, error)

DataSecurityLoSCapabilities gets the storage service's data security capabilities.

func (*StorageService) DataStorageLoSCapabilities 

func (storageservice *StorageService) DataStorageLoSCapabilities() (*DataStorageLoSCapabilities, error)

DataStorageLoSCapabilities references the data storage capabilities of this service.

func (*StorageService) DefaultClassOfService 

func (storageservice *StorageService) DefaultClassOfService() (*ClassOfService, error)

DefaultClassOfService references the default class of service for entities allocated by this storage service.

func (*StorageService) Drives 

func (storageservice *StorageService) Drives() ([]*redfish.Drive, error)

Drives gets the storage service's drives.

func (*StorageService) EndpointGroups 

func (storageservice *StorageService) EndpointGroups() ([]*EndpointGroup, error)

EndpointGroups gets the storage service's endpoint groups.

func (*StorageService) Endpoints 

func (storageservice *StorageService) Endpoints() ([]*redfish.Endpoint, error)

Endpoints gets the storage service's endpoints.

func (*StorageService) FileSystems 

func (storageservice *StorageService) FileSystems() ([]*FileSystem, error)

FileSystems gets all filesystems available through this storage service.

func (*StorageService) IOConnectivityLoSCapabilities 

func (storageservice *StorageService) IOConnectivityLoSCapabilities() (*IOConnectivityLoSCapabilities, error)

IOConnectivityLoSCapabilities references the IO connectivity capabilities of this service.

func (*StorageService) IOPerformanceLoSCapabilities 

func (storageservice *StorageService) IOPerformanceLoSCapabilities() (*IOPerformanceLoSCapabilities, error)

IOPerformanceLoSCapabilities references the IO performance capabilities of this service.

func (*StorageService) Redundancy 

func (storageservice *StorageService) Redundancy() ([]*redfish.Redundancy, error)

Redundancy gets the redundancy information for the storage subsystem.

func (*StorageService) SetEncryptionKey 

func (storageservice *StorageService) SetEncryptionKey(key string) error

SetEncryptionKey shall set the encryption key for the storage subsystem.

func (*StorageService) SpareResourceSets 

func (storageservice *StorageService) SpareResourceSets() ([]*SpareResourceSet, error)

SpareResourceSets gets resources that may be utilized to replace the capacity provided by a failed resource having a compatible type.

func (*StorageService) StorageGroups 

func (storageservice *StorageService) StorageGroups() ([]*StorageGroup, error)

StorageGroups gets the storage groups that are a part of this storage service.

func (*StorageService) UnmarshalJSON 

func (storageservice *StorageService) UnmarshalJSON(b []byte) error

UnmarshalJSON unmarshals a StorageService object from the raw JSON.

func (*StorageService) Volumes 

func (storageservice *StorageService) Volumes() ([]*Volume, error)

Volumes gets the volumes that are a part of this storage service.

type StorageSystem 

type StorageSystem struct {
	redfish.ComputerSystem
}

StorageSystem is a Swordfish storage system instance.

func GetStorageSystem 

func GetStorageSystem(c common.Client, uri string) (*StorageSystem, error)

GetStorageSystem will get a StorageSystem instance from the Swordfish service.

func ListReferencedStorageSystems 

func ListReferencedStorageSystems(c common.Client, link string) ([]*StorageSystem, error)

ListReferencedStorageSystems gets the collection of StorageSystems.

type UndiscoveredElement 

type UndiscoveredElement string

UndiscoveredElement is used to specify whether the source, the target, or both elements involved in a copy operation are undiscovered. An element shall be considered undiscovered if its object model is not known to the service performing the copy operation. 

const (
	// SourceElementUndiscoveredElement shall indicate that the source
	// element is undiscovered.
	SourceElementUndiscoveredElement UndiscoveredElement = "SourceElement"
	// ReplicaElementUndiscoveredElement shall indicate that the replica
	// element is undiscovered.
	ReplicaElementUndiscoveredElement UndiscoveredElement = "ReplicaElement"
)

type Volume 

type Volume struct {
	common.Entity

	// ODataContext is the odata context.
	ODataContext string `json:"@odata.context"`
	// ODataType is the odata type.
	ODataType string `json:"@odata.type"`
	// AccessCapabilities shall specify a current storage access capability.
	AccessCapabilities []StorageAccessCapability
	// BlockSizeBytes shall contain size of the smallest
	// addressable unit of the associated volume.
	BlockSizeBytes int
	// Capacity is Information about the utilization of capacity allocated to
	// this storage volume.
	Capacity Capacity
	// CapacityBytes shall contain the size in bytes of the
	// associated volume.
	CapacityBytes int
	// CapacitySources is Fully or partially consumed storage from a source
	// resource. Each entry provides capacity allocation information from a
	// named source resource.
	CapacitySources []CapacitySource
	// CapacitySources@odata.count is
	CapacitySourcesCount int `json:"CapacitySources@odata.count"`
	// Compressed shall contain a boolean indicator if the Volume is currently
	// utilizing compression or not.
	Compressed bool
	// Deduplicated shall contain a boolean indicator if the Volume is currently
	// utilizing deduplication or not.
	Deduplicated bool
	// Description provides a description of this resource.
	Description string
	// Encrypted shall contain a boolean indicator if the
	// Volume is currently utilizing encryption or not.
	Encrypted bool
	// EncryptionTypes is used by this Volume.
	EncryptionTypes []redfish.EncryptionTypes
	// IOStatistics shall represent IO statistics for this volume.
	// IOStatistics IOStatistics
	// Identifiers shall contain a list of all known durable
	// names for the associated volume.
	Identifiers []common.Identifier
	// Links is The Links property, as described by the Redfish
	// Specification, shall contain references to resources that are related
	// to, but not contained by (subordinate to), this resource.
	Links string
	// LogicalUnitNumber shall contain host-visible LogicalUnitNumber assigned
	// to this Volume. This property shall only be used when in a single connect
	// configuration and no StorageGroup configuration is used.
	LogicalUnitNumber int
	// LowSpaceWarningThresholdPercents is Each time the following value is
	// less than one of the values in the array the
	// LOW_SPACE_THRESHOLD_WARNING event shall be triggered: Across all
	// CapacitySources entries, percent = (SUM(AllocatedBytes) -
	// SUM(ConsumedBytes))/SUM(AllocatedBytes).
	LowSpaceWarningThresholdPercents []int
	// Manufacturer shall contain a value that represents
	// the manufacturer or implementer of the storage volume.
	Manufacturer string
	// MaxBlockSizeBytes shall contain size of the largest
	// addressable unit of this storage volume.
	MaxBlockSizeBytes int
	// MediaSpanCount shall indicate the number of media elements used per span
	// in the secondary RAID for a hierarchical RAID type.
	MediaSpanCount int
	// Model is The value is assigned by the manufacturer and shall
	// represents a specific storage volume implementation.
	Model string
	// Operations shall contain a list of all currently
	// running on the Volume.
	Operations []common.Operations
	// OptimumIOSizeBytes shall contain the optimum IO size
	// to use when performing IO on this volume. For logical disks, this is
	// the stripe size. For physical disks, this describes the physical
	// sector size.
	OptimumIOSizeBytes int
	// ProvisioningPolicy shall specify the volume's supported storage
	// allocation policy.
	ProvisioningPolicy ProvisioningPolicy
	// RAIDType shall contain the RAID type of the associated Volume.
	RAIDType RAIDType
	// ReadCachePolicy shall contain a boolean indicator of the read cache
	// policy for the Volume.
	ReadCachePolicy ReadCachePolicyType
	// RecoverableCapacitySourceCount is the number of available
	// capacity source resources currently available in the event that an
	// equivalent capacity source resource fails.
	RecoverableCapacitySourceCount int
	// RemainingCapacityPercent is if present, this value shall return
	// {[(SUM(AllocatedBytes) - SUM(ConsumedBytes)]/SUM(AllocatedBytes)}*100
	// represented as an integer value.
	RemainingCapacityPercent int
	// ReplicaInfo shall describe the replica relationship
	// between this storage volume and a corresponding source volume.
	// ReplicaInfo redfish.ReplicaInfo
	// ReplicaTargets shall reference the target replicas that
	// are sourced by this replica.
	ReplicaTargets []string
	// ReplicaTargets@odata.count is
	ReplicaTargetsCount int `json:"ReplicaTargets@odata.count"`
	// Status is
	Status common.Status
	// StripSizeBytes is the number of consecutively addressed virtual disk
	// blocks (bytes) mapped to consecutively addressed blocks on a single
	// member extent of a disk array. Synonym for stripe depth and chunk
	// size.
	StripSizeBytes int
	// VolumeUsage shall contain the volume usage type for the Volume.
	VolumeUsage VolumeUsageType
	// WriteCachePolicy shall contain a boolean indicator of the write cache
	// policy for the Volume.
	WriteCachePolicy WriteCachePolicyType
	// WriteCacheState shall contain the WriteCacheState policy setting for the
	// Volume.
	WriteCacheState WriteCacheStateType
	// WriteHoleProtectionPolicy specifies the policy that is enabled to address
	// the write hole issue on the RAID volume. If no policy is enabled at the
	// moment, this property shall be set to 'Off'.
	WriteHoleProtectionPolicy WriteHoleProtectionPolicyType

	// DedicatedSpareDrivesCount is the number of dedicates spare drives
	DedicatedSpareDrivesCount int
	// DrivesCount is the number of associated drives.
	DrivesCount int
	// SpareResourceSetsCount is the number of spare resources sets.
	SpareResourceSetsCount int

	// DisplayName shall contain a user-configurable string to name the volume.
	DisplayName string
	// contains filtered or unexported fields
}

Volume is used to represent a volume, virtual disk, logical disk, LUN, or other logical storage for a Redfish implementation.

func GetVolume 

func GetVolume(c common.Client, uri string) (*Volume, error)

GetVolume will get a Volume instance from the service.

func ListReferencedVolumes 

func ListReferencedVolumes(c common.Client, link string) ([]*Volume, error)

ListReferencedVolumes gets the collection of Volume from a provided reference.

func (*Volume) AssignReplicaTarget 

func (volume *Volume) AssignReplicaTarget(replicaType ReplicaType, updateMode ReplicaUpdateMode, targetVolumeODataID string) error

AssignReplicaTarget is used to establish a replication relationship by assigning an existing volume to serve as a target replica for an existing source volume.

func (*Volume) CheckConsistency 

func (volume *Volume) CheckConsistency() error

CheckConsistency is used to force a check of the Volume's parity or redundant data to ensure it matches calculated values.

func (*Volume) ClassOfService 

func (volume *Volume) ClassOfService() (*ClassOfService, error)

ClassOfService gets the class of service that this storage volume conforms to.

func (*Volume) DedicatedSpareDrives 

func (volume *Volume) DedicatedSpareDrives() ([]*redfish.Drive, error)

DedicatedSpareDrives references the Drives that are dedicated spares for this volume.

func (*Volume) Drives 

func (volume *Volume) Drives() ([]*redfish.Drive, error)

Drives references the Drives that are associated with this volume.

func (*Volume) Initialize 

func (volume *Volume) Initialize(initType InitializeType) error

Initialize is used to prepare the contents of the volume for use by the system.

func (*Volume) RemoveReplicaRelationship 

func (volume *Volume) RemoveReplicaRelationship(deleteTarget bool, targetVolumeODataID string) error

RemoveReplicaRelationship is used to disable data synchronization between a source and target volume, remove the replication relationship, and optionally delete the target volume.

func (*Volume) ResumeReplication 

func (volume *Volume) ResumeReplication(targetVolumeODataID string) error

ResumeReplication is used to resume the active data synchronization between a source and target volume, without otherwise altering the replication relationship.

func (*Volume) ReverseReplicationRelationship 

func (volume *Volume) ReverseReplicationRelationship(targetVolumeODataID string) error

ReverseReplicationRelationship is used to reverse the replication relationship between a source and target volume.

func (*Volume) SpareResourceSets 

func (volume *Volume) SpareResourceSets() ([]*SpareResourceSet, error)

SpareResourceSets gets the spare resources that can be used for this volume.

func (*Volume) SplitReplication 

func (volume *Volume) SplitReplication(targetVolumeODataID string) error

SplitReplication is used to split the replication relationship and suspend data synchronization between a source and target volume.

func (*Volume) StorageGroups 

func (volume *Volume) StorageGroups() ([]*StorageGroup, error)

StorageGroups gets the storage groups that associated with this volume.

func (*Volume) StoragePools 

func (volume *Volume) StoragePools() ([]*StoragePool, error)

StoragePools gets the storage pools that associated with this volume.

func (*Volume) SuspendReplication 

func (volume *Volume) SuspendReplication(targetVolumeODataID string) error

SuspendReplication is used to suspend active data synchronization between a source and target volume, without otherwise altering the replication relationship.

func (*Volume) UnmarshalJSON 

func (volume *Volume) UnmarshalJSON(b []byte) error

UnmarshalJSON unmarshals a Volume object from the raw JSON.

func (*Volume) Update added in v0.5.0 

func (volume *Volume) Update() error

Update commits updates to this object's properties to the running system.

type VolumeUsageType added in v0.5.0 

type VolumeUsageType string

VolumeUsageType is the type of volume usage. 

const (

	// DataVolumeUsageType shall be allocated for use as a consumable data
	// volume.
	DataVolumeUsageType VolumeUsageType = "Data"
	// SystemDataVolumeUsageType shall be allocated for use as a consumable
	// data volume reserved for system use.
	SystemDataVolumeUsageType VolumeUsageType = "SystemData"
	// CacheOnlyVolumeUsageType shall be allocated for use as a non-
	// consumable cache only volume.
	CacheOnlyVolumeUsageType VolumeUsageType = "CacheOnly"
	// SystemReserveVolumeUsageType shall be allocated for use as a non-
	// consumable system reserved volume.
	SystemReserveVolumeUsageType VolumeUsageType = "SystemReserve"
	// ReplicationReserveVolumeUsageType shall be allocated for use as a non-
	// consumable reserved volume for replication use.
	ReplicationReserveVolumeUsageType VolumeUsageType = "ReplicationReserve"
)

type WriteCachePolicyType added in v0.5.0 

type WriteCachePolicyType string

WriteCachePolicyType is the type of write cache policy. 

const (

	// WriteThroughWriteCachePolicyType A caching technique in which the
	// completion of a write request is not signaled until data is safely
	// stored on non-volatile media.
	WriteThroughWriteCachePolicyType WriteCachePolicyType = "WriteThrough"
	// ProtectedWriteBackWriteCachePolicyType A caching technique in which
	// the completion of a write request is signaled as soon as the data is
	// in cache, and actual writing to non-volatile media is guaranteed to
	// occur at a later time.
	ProtectedWriteBackWriteCachePolicyType WriteCachePolicyType = "ProtectedWriteBack"
	// UnprotectedWriteBackWriteCachePolicyType A caching technique in which
	// the completion of a write request is signaled as soon as the data is
	// in cache; actual writing to non-volatile media is not guaranteed to
	// occur at a later time.
	UnprotectedWriteBackWriteCachePolicyType WriteCachePolicyType = "UnprotectedWriteBack"
	// OffWriteCachePolicyType shall be disabled.
	OffWriteCachePolicyType WriteCachePolicyType = "Off"
)

type WriteCacheStateType added in v0.5.0 

type WriteCacheStateType string

WriteCacheStateType is the write cache state. 

const (

	// UnprotectedWriteCacheStateType Indicates that the cache state type in
	// use generally does not protect write requests on non-volatile media.
	UnprotectedWriteCacheStateType WriteCacheStateType = "Unprotected"
	// ProtectedWriteCacheStateType Indicates that the cache state type in
	// use generally protects write requests on non-volatile media.
	ProtectedWriteCacheStateType WriteCacheStateType = "Protected"
	// DegradedWriteCacheStateType Indicates an issue with the cache state in
	// which the cache space is diminished or disabled due to a failure or an
	// outside influence such as a discharged battery.
	DegradedWriteCacheStateType WriteCacheStateType = "Degraded"
)

type WriteHoleProtectionPolicyType added in v0.5.0 

type WriteHoleProtectionPolicyType string

WriteHoleProtectionPolicyType is the write hole protection policy. 

const (

	// OffWriteHoleProtectionPolicyType The support for addressing the write
	// hole issue is disabled. The volume is not performing any additional
	// activities to close the RAID write hole.
	OffWriteHoleProtectionPolicyType WriteHoleProtectionPolicyType = "Off"
	// JournalingWriteHoleProtectionPolicyType The policy that uses separate
	// block device for write-ahead logging to adddress write hole issue. All
	// write operations on the RAID volume are first logged on dedicated
	// journaling device that is not part of the volume.
	JournalingWriteHoleProtectionPolicyType WriteHoleProtectionPolicyType = "Journaling"
	// DistributedLogWriteHoleProtectionPolicyType The policy that
	// distributes additional log (e.q. cheksum of the parity) among the
	// volume's capacity sources to address write hole issue. Additional data
	// is used to detect data corruption on the volume.
	DistributedLogWriteHoleProtectionPolicyType WriteHoleProtectionPolicyType = "DistributedLog"
	// OEMWriteHoleProtectionPolicyType The policy that is Oem specific. The
	// mechanism details are unknown unless provided separatly by the Oem.
	OEMWriteHoleProtectionPolicyType WriteHoleProtectionPolicyType = "Oem"
)

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.