netapp

Documentation

Index

• Constants
• type AggrInfo
• type AggrInodeAttributes
• type AggrListPagesResponse
• type AggrListResponse
• type AggrOptions
• type AggrOwnershipAttributes
• type AggrRaidAttributes
• type AggrSpaceAttributes
• type AggrSpaceInfo
• type AggrSpaceInfoQuery
• type AggrSpaceListResponse
• type AggrSpaceOptions
• type AggrSpareDiskInfo
• type AggrSpareDiskInfoQuery
• type AggrSparesListPagesResponse
• type AggrSparesListResponse
• type AggrSparesOptions
• type Aggregate
  • func (a Aggregate) List(options *AggrOptions) (*AggrListResponse, *http.Response, error)
  • func (a *Aggregate) ListPages(options *AggrOptions, fn AggregatePageHandler)
• type AggregatePageHandler
• type AggregateSpace
  • func (a *AggregateSpace) List(options *AggrSpaceOptions) (*AggrSpaceListResponse, *http.Response, error)
• type AggregateSpares
  • func (a *AggregateSpares) List(options *AggrSparesOptions) (*AggrSparesListResponse, *http.Response, error)
  • func (a *AggregateSpares) ListPages(options *AggrSparesOptions, fn AggregateSparesPageHandler)
• type AggregateSparesPageHandler
• type AsyncResultBase
  • func (r *AsyncResultBase) Passed() bool
  • func (r *AsyncResultBase) Result() *SingleResultBase
• type Base
• type Cf
  • func (s *Cf) ClusterFailoverInfoList(options *ClusterFailoverInfoOptions) (*ClusterFailoverInfoResponse, *http.Response, error)
  • func (s *Cf) ClusterFailoverInfoListPages(options *ClusterFailoverInfoOptions, fn StorageFailoverInfoPageHandler)
• type Client
  • func NewClient(endpoint string, version string, options *ClientOptions) *Client
  • func (c *Client) Do(req *http.Request, v interface{}) (*http.Response, error)
  • func (c *Client) NewRequest(method string, body interface{}) (*http.Request, error)
• type ClientOptions
  • func DefaultOptions() *ClientOptions
• type ClusterFailoverInfoOptions
• type ClusterFailoverInfoPagesResponse
• type ClusterFailoverInfoResponse
• type ClusterIdentity
  • func (c *ClusterIdentity) List(options *ClusterIdentityOptions) (*ClusterIdentityResponse, *http.Response, error)
• type ClusterIdentityInfo
• type ClusterIdentityOptions
• type ClusterIdentityResponse
• type Diagnosis
  • func (v *Diagnosis) DiagnosisAlertGetAll(options *DiagnosisOptions, fn DiagnosisPageHandler)
  • func (v *Diagnosis) DiagnosisAlertGetIter(options *DiagnosisOptions) (*DiagnosisListResponse, *http.Response, error)
• type DiagnosisAlertInfo
• type DiagnosisAlertPagesResponse
• type DiagnosisListResponse
• type DiagnosisOptions
• type DiagnosisPageHandler
• type DiagnosisQuery
• type DiskInventoryInfo
• type DiskOwnershipInfo
• type ExportRuleListResponse
• type ExportRuleQuery
• type Fcp
  • func (f *Fcp) FcpAdapterGetAll(options *FcpAdapterConfigOptions, fn FcpAdapterConfigPageHandler)
  • func (f *Fcp) FcpAdapterGetIter(options *FcpAdapterConfigOptions) (*FcpAdapterConfigGetIterResponse, *http.Response, error)
• type FcpAdapterConfigGetIterResponse
• type FcpAdapterConfigInfo
• type FcpAdapterConfigOptions
• type FcpAdapterConfigPageHandler
• type FcpAdapterConfigPageResponse
• type FcpAdapterConfigQuery
• type Fcport
  • func (f *Fcport) GetLinkState(options *FcportGetLinkStateOptions) (*FcportGetLinkStateResponse, *http.Response, error)
• type FcportGetLinkStateOptions
• type FcportGetLinkStateResponse
• type FcportLinkStateInfo
• type GivebackRelatedInfo
• type InstanceData
• type InstanceInfo
• type InstanceInfoQuery
• type InterconnectRelatedInfo
• type Job
  • func (q *Job) Get(vserverName string, id int, options *JobOptions) (*JobResponse, *http.Response, error)
  • func (j Job) GetHistory(options *JobHistoryOptions) (*JobListResponse, *http.Response, error)
• type JobEntry
• type JobHistoryInfo
• type JobHistoryOptions
• type JobListResponse
• type JobOptions
• type JobResponse
  • func (j *JobResponse) JobState() string
  • func (j *JobResponse) Success() bool
• type Lun
  • func (v *Lun) List(options *LunOptions) (*LunListResponse, *http.Response, error)
  • func (v *Lun) ListPages(options *LunOptions, fn LunPageHandler)
• type LunInfo
• type LunListPagesResponse
• type LunListResponse
• type LunOptions
• type LunPageHandler
• type LunQuery
• type Net
  • func (n Net) CreateBroadcastDomain(createOptions *NetBroadcastDomainCreateOptions) (*NetBroadcastDomainCreateResponse, *http.Response, error)
  • func (n Net) CreateIPSpace(name string, returnRecord bool) (*NetIPSpaceResponse, *http.Response, error)
  • func (n Net) CreateNetInterface(options *NetInterfaceInfo) (*SingleResultResponse, *http.Response, error)
  • func (n Net) CreateRoute(vServerName string, options *NetRoutesInfo) (*NetRoutesResponse, *http.Response, error)
  • func (n Net) CreateVlan(options *NetVlanInfo) (*SingleResultResponse, *http.Response, error)
  • func (n Net) DeleteBroadcastDomain(domain string, ipSpace string) (*NetBroadcastDomainCreateResponse, *http.Response, error)
  • func (n Net) DeleteIPSpace(name string) (*NetIPSpaceResponse, *http.Response, error)
  • func (n Net) DeleteNetInterface(vServerName string, lif string) (*SingleResultResponse, *http.Response, error)
  • func (n Net) DeleteRoute(vServerName string, destination string, gateway string) (*SingleResultResponse, *http.Response, error)
  • func (n Net) DeleteVlan(options *NetVlanInfo) (*SingleResultResponse, *http.Response, error)
  • func (n Net) GetBroadcastDomain(domain string, ipSpace string) (*NetBroadcastDomainResponse, *http.Response, error)
  • func (n Net) GetIPSpace(name string) (*NetIPSpaceResponse, *http.Response, error)
  • func (n Net) GetVlan(interfaceName string, node string) (*NetVlanResponse, *http.Response, error)
  • func (n Net) ListIPSpaces(query *NetIPSpaceInfo) (*NetIPSpaceListResponse, *http.Response, error)
  • func (n Net) ListVlans(info *NetVlanInfo) (*NetVlanListResponse, *http.Response, error)
  • func (n *Net) NetInterfaceGetAll(options *NetInterfaceOptions, fn NetInterfacePageHandler)
  • func (n *Net) NetInterfaceGetIter(options *NetInterfaceOptions) (*NetInterfaceGetIterResponse, *http.Response, error)
  • func (n *Net) NetPortGetAll(options *NetPortOptions, fn NetPortPageHandler)
  • func (n *Net) NetPortGetIter(options *NetPortOptions) (*NetPortGetIterResponse, *http.Response, error)
  • func (n Net) RenameIPSpace(name string, newName string) (*NetIPSpaceResponse, *http.Response, error)
• type NetBroadcastDomainCreateOptions
• type NetBroadcastDomainCreateResponse
• type NetBroadcastDomainInfo
• type NetBroadcastDomainOptions
• type NetBroadcastDomainResponse
• type NetIPSpaceInfo
• type NetIPSpaceListResponse
• type NetIPSpaceOptions
• type NetIPSpaceResponse
• type NetInterfaceGetIterResponse
• type NetInterfaceInfo
• type NetInterfaceOptions
• type NetInterfacePageHandler
• type NetInterfacePageResponse
• type NetInterfaceQuery
• type NetPortGetIterResponse
• type NetPortInfo
• type NetPortOptions
• type NetPortPageHandler
• type NetPortPageResponse
• type NetPortQuery
• type NetPortUpdateInfo
• type NetRoutesInfo
• type NetRoutesResponse
• type NetVlanInfo
  • func (v *NetVlanInfo) ToString() string
• type NetVlanListResponse
• type NetVlanOptions
• type NetVlanResponse
• type NodeDetailOptions
• type NodeDetails
• type NodeDetailsPageHandler
• type NodeDetailsPagesResponse
• type NodeDetailsQuery
• type NodeDetailsResponse
• type NodeRelatedInfo
• type Perf
  • func (p *Perf) PerfObjectGetInstances(params *PerfObjectGetInstanceParams) (*PerfObjectGetInstancesResponse, *http.Response, error)
  • func (p *Perf) PerfObjectInstanceGetAllInfo(options *PerfObjectInstanceListInfoIterParams, ...)
  • func (p *Perf) PerfObjectInstanceListInfoIter(params *PerfObjectInstanceListInfoIterParams) (*PerfObjectInstanceListInfoIterResponse, *http.Response, error)
• type PerfCounterData
• type PerfCounters
• type PerfObjectGetInstanceParams
• type PerfObjectGetInstancesResponse
• type PerfObjectInstanceData
• type PerfObjectInstanceListInfoHandler
• type PerfObjectInstanceListInfoIterParams
• type PerfObjectInstanceListInfoIterResponse
• type PerfObjectInstanceListInfoPageResponse
• type QosPolicy
  • func (qp QosPolicy) ChangeIops(iops string, qosPolicyName string) (*QosPolicyResponse, *http.Response, error)
  • func (qp QosPolicy) Create(query *QosPolicyInfo) (*QosPolicyResponse, *http.Response, error)
  • func (qp QosPolicy) Delete(name string, force bool) (*QosPolicyResponse, *http.Response, error)
  • func (qp QosPolicy) Get(name string, query *QosPolicyInfo) (*QosPolicyResponse, *http.Response, error)
  • func (qp QosPolicy) Rename(info *QosPolicyRenameInfo) (*QosPolicyResponse, *http.Response, error)
• type QosPolicyInfo
• type QosPolicyRenameInfo
• type QosPolicyResponse
• type Qtree
  • func (q *Qtree) Create(vserverName, volume, qtree string, info *QtreeInfo) (*QtreeListResponse, *http.Response, error)
  • func (q *Qtree) Delete(vserverName, volName, qtreeName string, force bool) (*QtreeListResponse, *http.Response, error)
  • func (q *Qtree) DeleteAsync(vserverName, volName, qtreeName string) (*QtreeListResponse, *http.Response, error)
  • func (q *Qtree) List(options *QtreeOptions) (*QtreeListResponse, *http.Response, error)
• type QtreeInfo
• type QtreeListResponse
• type QtreeOptions
• type QtreeQuery
• type Quota
  • func (q *Quota) Create(serverName, target, quotaType, qtree string, entry *QuotaEntry) (*QuotaListResponse, *http.Response, error)
  • func (q *Quota) Delete(serverName, target, quotaType, volume, qtree string) (*QuotaListResponse, *http.Response, error)
  • func (q *Quota) Get(name string, options *QuotaOptions) (*QuotaResponse, *http.Response, error)
  • func (q *Quota) List(options *QuotaOptions) (*QuotaListResponse, *http.Response, error)
  • func (q *Quota) Off(serverName, volumeName string) (*QuotaStatusResponse, *http.Response, error)
  • func (q *Quota) On(serverName, volumeName string) (*QuotaStatusResponse, *http.Response, error)
  • func (q *Quota) Status(serverName, volumeName string) (*QuotaStatusResponse, *http.Response, error)
  • func (q *Quota) Update(serverName string, entry *QuotaEntry) (*QuotaListResponse, *http.Response, error)
• type QuotaEntry
• type QuotaListResponse
• type QuotaOptions
• type QuotaQuery
• type QuotaReport
  • func (qr *QuotaReport) Report(options *QuotaReportOptions) (*QuotaReportResponse, *http.Response, error)
  • func (a *QuotaReport) ReportPages(options *QuotaReportOptions, fn QuotaReportPageHandler)
• type QuotaReportEntry
• type QuotaReportEntryQuery
• type QuotaReportOptions
• type QuotaReportPageHandler
• type QuotaReportPagesResponse
• type QuotaReportResponse
• type QuotaResponse
• type QuotaStatus
  • func (qr *QuotaStatus) StatusIter(options *QuotaStatusIterOptions) (*QuotaStatusIterResponse, *http.Response, error)
  • func (a *QuotaStatus) StatusPages(options *QuotaStatusIterOptions, fn QuotaStatusPageHandler)
• type QuotaStatusEntry
• type QuotaStatusEntryQuery
• type QuotaStatusIterOptions
• type QuotaStatusIterResponse
• type QuotaStatusPageHandler
• type QuotaStatusPagesResponse
• type QuotaStatusResponse
• type Result
• type ResultBase
  • func (r *ResultBase) Passed() bool
  • func (r *ResultBase) Result() *SingleResultBase
• type SingleResultBase
  • func (r *SingleResultBase) Passed() bool
  • func (r *SingleResultBase) Result() *SingleResultBase
• type SingleResultResponse
• type Snapmirror
  • func (s Snapmirror) AbortBy(query *SnapmirrorInfo, continueOnFailure bool) (*SnapmirrorIterResponse, *http.Response, error)
  • func (s Snapmirror) Create(vServerName string, attributes *SnapmirrorInfo) (*SingleResultResponse, *http.Response, error)
  • func (s Snapmirror) DestroyBy(query *SnapmirrorInfo, continueOnFailure bool) (*SnapmirrorIterResponse, *http.Response, error)
  • func (s Snapmirror) Get(vServerName string, sourcePath string, destinationPath string, ...) (*SnapmirrorResponse, *http.Response, error)
  • func (s Snapmirror) InitializeLSSet(vServerName string, sourcePath string) (*SnapmirrorAsyncResponse, *http.Response, error)
  • func (s Snapmirror) UpdateLSSet(vServerName string, sourcePath string) (*SnapmirrorAsyncResponse, *http.Response, error)
• type SnapmirrorAsyncResponse
• type SnapmirrorInfo
• type SnapmirrorIterResponse
• type SnapmirrorResponse
• type Snapshot
  • func (v *Snapshot) List(options *SnapshotOptions) (*SnapshotListResponse, *http.Response, error)
  • func (v *Snapshot) ListPages(options *SnapshotOptions, fn SnapshotPageHandler)
• type SnapshotInfo
• type SnapshotListPagesResponse
• type SnapshotListResponse
• type SnapshotOptions
• type SnapshotPageHandler
• type SnapshotQuery
• type StorageDisk
  • func (s *StorageDisk) StorageDiskGetAll(options *StorageDiskOptions, fn StorageDiskGetAllPageHandler)
  • func (s *StorageDisk) StorageDiskGetIter(options *StorageDiskOptions) (*StorageDiskGetIterResponse, *http.Response, error)
• type StorageDiskGetAllPageHandler
• type StorageDiskGetIterResponse
• type StorageDiskInfo
• type StorageDiskInfoPageResponse
• type StorageDiskOptions
• type StorageFailoverInfo
• type StorageFailoverInfoPageHandler
• type StorageFailoverInfoQuery
• type System
  • func (s *System) List(options *NodeDetailOptions) (*NodeDetailsResponse, *http.Response, error)
  • func (s *System) ListPages(options *NodeDetailOptions, fn NodeDetailsPageHandler)
• type TakeoverRelatedInfo
• type VServer
  • func (v VServer) AddInitiator(vServerName string, iGroupName string, initiator string) (*VServerIgroupsResponse, *http.Response, error)
  • func (v VServer) Create(options *VServerInfo) (*VServerAsyncResponse, *http.Response, error)
  • func (v VServer) CreateExportRule(vServerName string, options *VServerExportRuleInfo) (*VServerExportsResponse, *http.Response, error)
  • func (v VServer) CreateNfsService(vServerName string, options *VServerNfsCreateOptions) (*SingleResultResponse, *http.Response, error)
  • func (v VServer) Delete(name string) (*VServerListResponse, *http.Response, error)
  • func (v VServer) DeleteExportRule(vServerName string, policyName string, ruleIndex int) (*VServerExportsResponse, *http.Response, error)
  • func (v VServer) Get(name string, options *VServerOptions) (*VServerResponse, *http.Response, error)
  • func (v VServer) List(options *VServerOptions) (*VServerListResponse, *http.Response, error)
  • func (v VServer) ListExportRules(vServerName string) (*ExportRuleListResponse, *http.Response, error)
  • func (v VServer) Modify(name string, options *VServerInfo) (*SingleResultResponse, *http.Response, error)
  • func (v VServer) RemoveInitiator(vServerName string, iGroupName string, initiator string, force bool) (*VServerIgroupsResponse, *http.Response, error)
• type VServerAsyncResponse
• type VServerExportRuleInfo
• type VServerExportsResponse
• type VServerIgroupInfo
• type VServerIgroupsResponse
• type VServerInfo
• type VServerListResponse
• type VServerNfsCreateOptions
• type VServerOptions
• type VServerQuery
• type VServerResponse
• type Volume
  • func (v Volume) List(options *VolumeOptions) (*VolumeListResponse, *http.Response, error)
  • func (v *Volume) ListPages(options *VolumeOptions, fn VolumePageHandler)
  • func (v Volume) Modify(options *VolumeOptions) (*VolumeModifyResponce, *http.Response, error)
• type VolumeAntivirusAttributes
• type VolumeAutobalanceAttributes
• type VolumeAutosizeAttributes
• type VolumeCreateOptions
• type VolumeDirectoryAttributes
• type VolumeExportAttributes
• type VolumeHybridCacheAttributes
• type VolumeIDAttributes
• type VolumeInfo
• type VolumeInodeAttributes
• type VolumeLanguageAttributes
• type VolumeListPagesResponse
• type VolumeListResponse
• type VolumeMirrorAttributes
• type VolumeModifyInfo
• type VolumeModifyOptions
• type VolumeModifyResponce
• type VolumeOperation
  • func (v VolumeOperation) Create(vserverName string, options *VolumeCreateOptions) (*SingleResultResponse, *http.Response, error)
  • func (v VolumeOperation) Operation(vserverName string, volName string, operation string) (*SingleResultResponse, *http.Response, error)
• type VolumeOptions
• type VolumePageHandler
• type VolumePerformanceAttributes
• type VolumeQosAttributes
• type VolumeQuery
• type VolumeSecurityAttributes
• type VolumeSisAttributes
• type VolumeSnaplockAttributes
• type VolumeSnapshotAttributes
• type VolumeSnapshotAutodeleteAttributes
• type VolumeSpace
  • func (v *VolumeSpace) List(options *VolumeSpaceOptions) (*VolumeSpaceListResponse, *http.Response, error)
• type VolumeSpaceAttributes
• type VolumeSpaceInfo
• type VolumeSpaceInfoQuery
• type VolumeSpaceListResponse
• type VolumeSpaceOptions
• type VolumeSpacesInfo
  • func (v VolumeSpacesInfo) Len() int
  • func (p VolumeSpacesInfo) Less(i, j int) bool
  • func (v VolumeSpacesInfo) Swap(i, j int)
• type VolumeStateAttributes
• type VolumeTransitionAttributes

Constants

const (
	ServerURL = `/servlets/netapp.servlets.admin.XMLrequest_filer`

	XMLNs = "http://www.netapp.com/filer/admin"
)

const (
	QuotaStatusCorrupt      = "corrupt"
	QuotaStatusInitializing = "initializing"
	QuotaStatusMixed        = "mixed"
	QuotaStatusOff          = "off"
	QuotaStatusOn           = "on"
	QuotaStatusResizing     = "resizing"
	QuotaStatusReverting    = "reverting"
	QuotaStatusUnknown      = "unknown"
	QuotaStatusUpgrading    = "upgrading"
)

const (
	SnapmirrorRelationshipDP  string = "data_protection"
	SnapmirrorRelationshipLS  string = "load_sharing"
	SnapmirrorRelationshipV   string = "vault"
	SnapmirrorRelationshipR   string = "restore"
	SnapmirrorRelationshipTDP string = "transition_data_protection"
	SnapmirrorRelationshipEDP string = "extended_data_protection"
)

Snapmirror Relationship Types

const (
	VolumeCreateOperation   = "volume-create"
	VolumeOfflineOperation  = "volume-offline"
	VolumeOnlineOperation   = "volume-online"
	VolumeDestroyOperation  = "volume-destroy"
	VolumeUnmountOperation  = "volume-unmount"
	VolumeRestrictOperation = "volume-restrict"
)

These consts are for defined volume operations

Types

type AggrInfo

type AggrInfo struct {
	AggregateName           string                   `xml:"aggregate-name,omitempty"`
	AggrInodeAttributes     *AggrInodeAttributes     `xml:"aggr-inode-attributes,omitempty"`
	AggrSpaceAttributes     *AggrSpaceAttributes     `xml:"aggr-space-attributes,omitempty"`
	AggrOwnershipAttributes *AggrOwnershipAttributes `xml:"aggr-ownership-attributes,omitempty"`
	AggrRaidAttributes      *AggrRaidAttributes      `xml:"aggr-raid-attributes,omitempty"`
}

type AggrInodeAttributes

type AggrInodeAttributes struct {
	FilesPrivateUsed         int `xml:"files-private-used"`
	FilesTotal               int `xml:"files-total"`
	FilesUsed                int `xml:"files-used"`
	InodefilePrivateCapacity int `xml:"inodefile-private-capacity"`
	InodefilePublicCapacity  int `xml:"inodefile-public-capacity"`
	MaxfilesAvailable        int `xml:"maxfiles-available"`
	MaxfilesPossible         int `xml:"maxfiles-possible"`
	MaxfilesUsed             int `xml:"maxfiles-used"`
	PercentInodeUsedCapacity int `xml:"percent-inode-used-capacity"`
}

type AggrListPagesResponse

type AggrListPagesResponse struct {
	Response    *AggrListResponse
	Error       error
	RawResponse *http.Response
}

type AggrListResponse

type AggrListResponse struct {
	XMLName xml.Name `xml:"netapp"`
	Results struct {
		ResultBase
		AggrAttributes []AggrInfo `xml:"attributes-list>aggr-attributes"`
		NextTag        string     `xml:"next-tag"`
	} `xml:"results"`
}

type AggrOptions

type AggrOptions struct {
	DesiredAttributes *AggrInfo `xml:"desired-attributes>aggr-attributes,omitempty"`
	MaxRecords        int       `xml:"max-records,omitempty"`
	Query             *AggrInfo `xml:"query>aggr-attributes,omitempty"`
	Tag               string    `xml:"tag,omitempty"`
}

type AggrOwnershipAttributes

type AggrOwnershipAttributes struct {
	Cluster   string `xml:"cluster"`
	HomeID    int    `xml:"home-id"`
	HomeName  string `xml:"home-name"`
	OwnerID   int    `xml:"owner-id"`
	OwnerName string `xml:"owner-name"`
}

AggrOwnershipAttributes describe aggregate's ownership

type AggrRaidAttributes

type AggrRaidAttributes struct {
	AggregateType      string `xml:"aggregate-type,omitempty"`
	CacheRaidGroupSize int    `xml:"cache-raid-group-size,omitempty"`
	ChecksumStatus     string `xml:"checksum-status,omitempty"`
	ChecksumStyle      string `xml:"checksum-style,omitempty"`
	DiskCount          int    `xml:"disk-count,omitempty"`
	EncryptionKeyID    string `xml:"encryption-key-id,omitempty"`
	HaPolicy           string `xml:"ha-policy,omitempty"`
	HasLocalRoot       *bool  `xml:"has-local-root"`
	HasPartnerRoot     *bool  `xml:"has-partner-root"`
	IsChecksumEnabled  *bool  `xml:"is-checksum-enabled"`
	IsEncrypted        *bool  `xml:"is-encrypted"`
	IsHybrid           *bool  `xml:"is-hybrid"`
	IsHybridEnabled    *bool  `xml:"is-hybrid-enabled"`
	IsInconsistent     *bool  `xml:"is-inconsistent"`
	IsMirrored         *bool  `xml:"is-mirrored"`
	IsRootAggregate    *bool  `xml:"is-root-aggregate"`
	MirrorStatus       string `xml:"mirror-status,omitempty"`
	MountState         string `xml:"mount-state,omitempty"`
	PlexCount          int    `xml:"plex-count,omitempty"`
	RaidLostWriteState string `xml:"raid-lost-write-state,omitempty"`
	RaidSize           int    `xml:"raid-size,omitempty"`
	RaidStatus         string `xml:"raid-status,omitempty"`
	RaidType           string `xml:"raid-type,omitempty"`
	State              string `xml:"state,omitempty"`
	UsesSharedDisks    *bool  `xml:"uses-shared-disks"`
}

type AggrSpaceAttributes

type AggrSpaceAttributes struct {
	AggregateMetadata            string `xml:"aggregate-metadata"`
	HybridCacheSizeTotal         string `xml:"hybrid-cache-size-total"`
	PercentUsedCapacity          string `xml:"percent-used-capacity"`
	PhysicalUsed                 int    `xml:"physical-used"`
	PhysicalUsedPercent          int    `xml:"physical-used-percent"`
	SizeAvailable                int    `xml:"size-available"`
	SizeTotal                    int    `xml:"size-total"`
	SizeUsed                     int    `xml:"size-used"`
	TotalReservedSpace           int    `xml:"total-reserved-space"`
	UsedIncludingSnapshotReserve string `xml:"used-including-snapshot-reserve"`
	VolumeFootprints             string `xml:"volume-footprints"`
}

type AggrSpaceInfo

type AggrSpaceInfo struct {
	Aggregate                           string `xml:"aggregate,omitempty"`
	AggregateMetadata                   string `xml:"aggregate-metadata,omitempty"`
	AggregateMetadataPercent            string `xml:"aggregate-metadata-percent,omitempty"`
	AggregateSize                       string `xml:"aggregate-size,omitempty"`
	PercentSnapshotSpace                string `xml:"percent-snapshot-space,omitempty"`
	PhysicalUsed                        string `xml:"physical-used,omitempty"`
	PhysicalUsedPercent                 string `xml:"physical-used-percent,omitempty"`
	SnapSizeTotal                       string `xml:"snap-size-total,omitempty"`
	SnapshotReserveUnusable             string `xml:"snapshot-reserve-unusable,omitempty"`
	SnapshotReserveUnusablePercent      string `xml:"snapshot-reserve-unusable-percent,omitempty"`
	UsedIncludingSnapshotReserve        string `xml:"used-including-snapshot-reserve,omitempty"`
	UsedIncludingSnapshotReservePercent string `xml:"used-including-snapshot-reserve-percent,omitempty"`
	VolumeFootprints                    string `xml:"volume-footprints,omitempty"`
	VolumeFootprintsPercent             string `xml:"volume-footprints-percent,omitempty"`
}

type AggrSpaceInfoQuery

type AggrSpaceInfoQuery struct {
	AggrSpaceInfo *AggrSpaceInfo `xml:"space-information,omitempty"`
}

type AggrSpaceListResponse

type AggrSpaceListResponse struct {
	XMLName xml.Name `xml:"netapp"`
	Results struct {
		ResultBase
		AttributesList struct {
			AggrAttributes []AggrSpaceInfo `xml:"space-information"`
		} `xml:"attributes-list"`
	} `xml:"results"`
}

type AggrSpaceOptions

type AggrSpaceOptions struct {
	DesiredAttributes *AggrSpaceInfoQuery `xml:"desired-attributes,omitempty"`
	MaxRecords        int                 `xml:"max-records,omitempty"`
	Query             *AggrSpaceInfoQuery `xml:"query,omitempty"`
	Tag               string              `xml:"tag,omitempty"`
}

type AggrSpareDiskInfo

type AggrSpareDiskInfo struct {
	ChecksumStyle           string `xml:"checksum-style"`
	Disk                    string `xml:"disk"`
	DiskRpm                 int    `xml:"disk-rpm"`
	DiskType                string `xml:"disk-type"`
	EffectiveDiskRpm        int    `xml:"effective-disk-rpm"`
	EffectiveDiskType       string `xml:"effective-disk-type"`
	IsDiskLeftBehind        bool   `xml:"is-disk-left-behind"`
	IsDiskShared            bool   `xml:"is-disk-shared"`
	IsDiskZeroed            bool   `xml:"is-disk-zeroed"`
	IsDiskZeroing           bool   `xml:"is-disk-zeroing"`
	IsSparecore             bool   `xml:"is-sparecore"`
	LocalUsableDataSize     int    `xml:"local-usable-data-size"`
	LocalUsableDataSizeBlks int    `xml:"local-usable-data-size-blks"`
	LocalUsableRootSize     int    `xml:"local-usable-root-size"`
	LocalUsableRootSizeBlks int    `xml:"local-usable-root-size-blks"`
	OriginalOwner           string `xml:"original-owner"`
	SyncmirrorPool          string `xml:"syncmirror-pool"`
	TotalSize               int    `xml:"total-size"`
	UsableSize              int    `xml:"usable-size"`
	UsableSizeBlks          int    `xml:"usable-size-blks"`
	ZeroingPercent          int    `xml:"zeroing-percent"`
}

type AggrSpareDiskInfoQuery

type AggrSpareDiskInfoQuery struct {
	AggrSpareDiskInfo *AggrSpareDiskInfo `xml:"aggr-spare-disk-info,omitempty"`
}

type AggrSparesListPagesResponse

type AggrSparesListPagesResponse struct {
	Response    *AggrSparesListResponse
	Error       error
	RawResponse *http.Response
}

type AggrSparesListResponse

type AggrSparesListResponse struct {
	XMLName xml.Name `xml:"netapp"`
	Results struct {
		ResultBase
		AttributesList struct {
			AggrAttributes []AggrSpareDiskInfo `xml:"aggr-spare-disk-info"`
		} `xml:"attributes-list"`
		NextTag    string `xml:"next-tag"`
		NumRecords int    `xml:"num-records"`
	} `xml:"results"`
}

type AggrSparesOptions

type AggrSparesOptions struct {
	DesiredAttributes *AggrSpareDiskInfoQuery `xml:"desired-attributes,omitempty"`
	MaxRecords        int                     `xml:"max-records,omitempty"`
	Query             *AggrSpareDiskInfoQuery `xml:"query,omitempty"`
	Tag               string                  `xml:"tag,omitempty"`
}

type Aggregate

type Aggregate struct {
	Base
	Params struct {
		XMLName xml.Name
		AggrOptions
	}
}

func (Aggregate) List

func (a Aggregate) List(options *AggrOptions) (*AggrListResponse, *http.Response, error)

func (*Aggregate) ListPages

func (a *Aggregate) ListPages(options *AggrOptions, fn AggregatePageHandler)

type AggregatePageHandler

type AggregatePageHandler func(AggrListPagesResponse) (shouldContinue bool)

type AggregateSpace

type AggregateSpace struct {
	Base
	Params struct {
		XMLName xml.Name
		*AggrSpaceOptions
	}
}

func (*AggregateSpace) List

func (a *AggregateSpace) List(options *AggrSpaceOptions) (*AggrSpaceListResponse, *http.Response, error)

type AggregateSpares

type AggregateSpares struct {
	Base
	Params struct {
		XMLName xml.Name
		*AggrSparesOptions
	}
}

func (*AggregateSpares) List

func (a *AggregateSpares) List(options *AggrSparesOptions) (*AggrSparesListResponse, *http.Response, error)

func (*AggregateSpares) ListPages

func (a *AggregateSpares) ListPages(options *AggrSparesOptions, fn AggregateSparesPageHandler)

type AggregateSparesPageHandler

type AggregateSparesPageHandler func(AggrSparesListPagesResponse) (shouldContinue bool)

type AsyncResultBase

type AsyncResultBase struct {
	SingleResultBase
	ErrorCode    int    `xml:"result-error-code"`
	ErrorMessage string `xml:"result-error-message"`
	JobID        int    `xml:"result-jobid"`
	JobStatus    string `xml:"result-status"`
}

func (*AsyncResultBase) Passed

func (r *AsyncResultBase) Passed() bool

func (*AsyncResultBase) Result

func (r *AsyncResultBase) Result() *SingleResultBase

type Base

type Base struct {
	XMLName xml.Name `xml:"netapp"`
	Version string   `xml:"version,attr"`
	XMLNs   string   `xml:"xmlsns,attr"`
	Name    string   `xml:"vfiler,attr,omitempty"`
	// contains filtered or unexported fields
}

type Cf

type Cf struct {
	Base
	Params struct {
		XMLName xml.Name
		*ClusterFailoverInfoOptions
	}
}

func (*Cf) ClusterFailoverInfoList

func (s *Cf) ClusterFailoverInfoList(options *ClusterFailoverInfoOptions) (*ClusterFailoverInfoResponse, *http.Response, error)

func (*Cf) ClusterFailoverInfoListPages

func (s *Cf) ClusterFailoverInfoListPages(options *ClusterFailoverInfoOptions, fn StorageFailoverInfoPageHandler)

type Client

type Client struct {
	BaseURL   *url.URL
	UserAgent string

	ResponseTimeout  time.Duration
	Aggregate        *Aggregate
	AggregateSpace   *AggregateSpace
	AggregateSpares  *AggregateSpares
	Cf               *Cf
	ClusterIdentity  *ClusterIdentity
	Diagnosis        *Diagnosis
	Fcp              *Fcp
	Fcport           *Fcport
	Job              *Job
	Lun              *Lun
	Net              *Net
	Perf             *Perf
	Qtree            *Qtree
	QosPolicy        *QosPolicy
	Quota            *Quota
	QuotaReport      *QuotaReport
	QuotaStatus      *QuotaStatus
	Snapshot         *Snapshot
	Snapmirror       *Snapmirror
	StorageDisk      *StorageDisk
	System           *System
	Volume           *Volume
	VolumeSpace      *VolumeSpace
	VolumeOperations *VolumeOperation
	VServer          *VServer
	// contains filtered or unexported fields
}

A Client manages communication with the GitHub API.

func NewClient

func NewClient(endpoint string, version string, options *ClientOptions) *Client

func (*Client) Do

func (c *Client) Do(req *http.Request, v interface{}) (*http.Response, error)

func (*Client) NewRequest

func (c *Client) NewRequest(method string, body interface{}) (*http.Request, error)

type ClientOptions

type ClientOptions struct {
	BasicAuthUser     string
	BasicAuthPassword string
	SSLVerify         bool
	Debug             bool
	Timeout           time.Duration
}

func DefaultOptions

func DefaultOptions() *ClientOptions

type ClusterFailoverInfoOptions

type ClusterFailoverInfoOptions struct {
	DesiredAttributes *StorageFailoverInfoQuery `xml:"desired-attributes,omitempty"`
	MaxRecords        int                       `xml:"max-records,omitempty"`
	Query             *StorageFailoverInfoQuery `xml:"query,omitempty"`
	Tag               string                    `xml:"tag,omitempty"`
}

type ClusterFailoverInfoPagesResponse

type ClusterFailoverInfoPagesResponse struct {
	Response    *ClusterFailoverInfoResponse
	Error       error
	RawResponse *http.Response
}

type ClusterFailoverInfoResponse

type ClusterFailoverInfoResponse struct {
	XMLName xml.Name `xml:"netapp"`
	Results struct {
		ResultBase
		AttributesList []StorageFailoverInfo `xml:"attributes-list>storage-failover-info"`
		NextTag        string                `xml:"next-tag"`
		NumRecords     int                   `xml:"num-records"`
	} `xml:"results"`
}

type ClusterIdentity

type ClusterIdentity struct {
	Base
	Params struct {
		XMLName xml.Name
		*ClusterIdentityOptions
	}
}

func (*ClusterIdentity) List

func (c *ClusterIdentity) List(options *ClusterIdentityOptions) (*ClusterIdentityResponse, *http.Response, error)

type ClusterIdentityInfo

type ClusterIdentityInfo struct {
	ClusterContact      string `xml:"cluster-contact,omitempty"`
	ClusterLocation     string `xml:"cluster-location"`
	ClusterName         string `xml:"cluster-name"`
	ClusterSerialNumber string `xml:"cluster-serial-number"`
	RdbUuid             string `xml:"rdb-uuid"`
	UUID                string `xml:"uuid"`
}

type ClusterIdentityOptions

type ClusterIdentityOptions struct {
	DesiredAttributes *ClusterIdentityInfo `xml:"desired-attributes,omitempty"`
}

type ClusterIdentityResponse

type ClusterIdentityResponse struct {
	XMLName xml.Name `xml:"netapp"`
	Results struct {
		ResultBase
		ClusterIdentityInfo []ClusterIdentityInfo `xml:"attributes>cluster-identity-info"`
	} `xml:"results"`
}

type Diagnosis

type Diagnosis struct {
	Base
	Params struct {
		XMLName xml.Name
		*DiagnosisOptions
	}
}

func (*Diagnosis) DiagnosisAlertGetAll

func (v *Diagnosis) DiagnosisAlertGetAll(options *DiagnosisOptions, fn DiagnosisPageHandler)

func (*Diagnosis) DiagnosisAlertGetIter

func (v *Diagnosis) DiagnosisAlertGetIter(options *DiagnosisOptions) (*DiagnosisListResponse, *http.Response, error)

type DiagnosisAlertInfo

type DiagnosisAlertInfo struct {
	Acknowledge              bool   `xml:"acknowledge"`
	Acknowledger             string `xml:"acknowledger"`
	Additionalinfo           string `xml:"additional-info"`
	AlertId                  string `xml:"alert-id"`
	AlertingResource         string `xml:"alerting-resource"`
	AlertingResourceName     string `xml:"alerting-resource-name"`
	CorrectiveActions        string `xml:"corrective-actions"`
	IndicationTime           int    `xml:"indication-time"`
	Monitor                  string `xml:"monitor"`
	Node                     string `xml:"node"`
	PerceivedSeverity        string `xml:"perceived-severity"`
	Policy                   string `xml:"policy"`
	PossibleEffect           string `xml:"possible-effect"`
	ProbableCause            string `xml:"probable-cause"`
	ProbableCauseDescription string `xml:"probable-cause-description"`
	Subsystem                string `xml:"subsystem"`
	Suppress                 bool   `xml:"suppress"`
	Suppressor               string `xml:"suppressor"`
}

type DiagnosisAlertPagesResponse

type DiagnosisAlertPagesResponse struct {
	Response    *DiagnosisListResponse
	Error       error
	RawResponse *http.Response
}

type DiagnosisListResponse

type DiagnosisListResponse struct {
	XMLName xml.Name `xml:"netapp"`
	Results struct {
		ResultBase
		AttributesList struct {
			DiagnosisAttributes []DiagnosisAlertInfo `xml:"diagnosis-alert-info"`
		} `xml:"attributes-list"`
		NextTag    string `xml:"next-tag"`
		NumRecords int    `xml:"num-records"`
	} `xml:"results"`
}

type DiagnosisOptions

type DiagnosisOptions struct {
	DesiredAttributes *DiagnosisAlertInfo `xml:"desired-attributes,omitempty"`
	MaxRecords        int                 `xml:"max-records,omitempty"`
	Query             *DiagnosisQuery     `xml:"query,omitempty"`
	Tag               string              `xml:"tag,omitempty"`
}

type DiagnosisPageHandler

type DiagnosisPageHandler func(DiagnosisAlertPagesResponse) (shouldContinue bool)

type DiagnosisQuery

type DiagnosisQuery struct {
	DiagnosisInfo *DiagnosisAlertInfo `xml:"diagnosis-alert-info,omitempty"`
}

type DiskInventoryInfo

type DiskInventoryInfo struct {
	BytesPerSector                 int    `xml:"bytes-per-sector,omitempty"`
	CapacitySectors                int    `xml:"capacity-sectors,omitempty"`
	ChecksumCompatibility          string `xml:"checksum-compatibility,omitempty"`
	DiskClusterName                string `xml:"disk-cluster-name,omitempty"`
	DiskType                       string `xml:"disk-type,omitempty"`
	DiskUid                        string `xml:"disk-uid,omitempty"`
	FirmwareRevision               string `xml:"firmware-revision,omitempty"`
	GrownDefectListCount           int    `xml:"grown-defect-list-count,omitempty"`
	HealthMonitorTimeInterval      int    `xml:"health-monitor-time-interval,omitempty"`
	ImportInProgress               *bool  `xml:"import-in-progress,omitempty"`
	IsDynamicallyQualified         *bool  `xml:"is-dynamically-qualified,omitempty"`
	IsMultidiskCarrier             *bool  `xml:"is-multidisk-carrier,omitempty"`
	IsShared                       *bool  `xml:"is-shared,omitempty"`
	MediaScrubCount                int    `xml:"media-scrub-count,omitempty"`
	MediaScrubLastDoneTimeInterval int    `xml:"media-scrub-last-done-time-interval,omitempty"`
	Model                          string `xml:"model,omitempty"`
	ReservationKey                 string `xml:"reservation-key,omitempty"`
	ReservationType                string `xml:"reservation-type,omitempty"`
	RightSizeSectors               int    `xml:"right-size-sectors,omitempty"`
	Rpm                            int    `xml:"rpm,omitempty"`
	SerialNumber                   string `xml:"serial-number,omitempty"`
	Shelf                          string `xml:"shelf,omitempty"`
	ShelfBay                       string `xml:"shelf-bay,omitempty"`
	ShelfUid                       string `xml:"shelf-uid,omitempty"`
	StackID                        int    `xml:"stack-id,omitempty"`
	Vendor                         string `xml:"vendor,omitempty"`
}

type DiskOwnershipInfo

type DiskOwnershipInfo struct {
	DiskUid          string `xml:"disk-uid,omitempty"`
	DrHomeNodeId     int    `xml:"dr-home-node-id,omitempty"`
	DrHomeNodeName   string `xml:"dr-home-node-name,omitempty"`
	HomeNodeId       int    `xml:"home-node-id,omitempty"`
	HomeNodeName     string `xml:"home-node-name,omitempty"`
	IsFailed         *bool  `xml:"is-failed,omitempty"`
	OwnerNodeId      int    `xml:"owner-node-id,omitempty"`
	OwnerNodeName    string `xml:"owner-node-name,omitempty"`
	Pool             int    `xml:"pool,omitempty"`
	ReservedByNodeId int    `xml:"reserved-by-node-id,omitempty"`
}

type ExportRuleListResponse

type ExportRuleListResponse struct {
	XMLName xml.Name `xml:"netapp"`
	Results struct {
		ResultBase
		AttributesList struct {
			VServerExportRuleInfo []VServerExportRuleInfo `xml:"export-rule-info"`
		} `xml:"attributes-list"`
	} `xml:"results"`
}

type ExportRuleQuery

type ExportRuleQuery struct {
	ExportRuleInfo *VServerExportRuleInfo `xml:"export-rule-info,omitempty"`
}

type Fcp

type Fcp struct {
	Base
	Params struct {
		XMLName xml.Name
		*FcpAdapterConfigOptions
	}
}

func (*Fcp) FcpAdapterGetAll

func (f *Fcp) FcpAdapterGetAll(options *FcpAdapterConfigOptions, fn FcpAdapterConfigPageHandler)

func (*Fcp) FcpAdapterGetIter

func (f *Fcp) FcpAdapterGetIter(options *FcpAdapterConfigOptions) (*FcpAdapterConfigGetIterResponse, *http.Response, error)

type FcpAdapterConfigGetIterResponse

type FcpAdapterConfigGetIterResponse struct {
	XMLName xml.Name `xml:"netapp"`
	Results struct {
		ResultBase
		AttributesList struct {
			FcpAdapterAttributes []FcpAdapterConfigInfo `xml:"fcp-config-adapter-info"`
		} `xml:"attributes-list"`
		NextTag    string `xml:"next-tag"`
		NumRecords int    `xml:"num-records"`
	} `xml:"results"`
}

type FcpAdapterConfigInfo

type FcpAdapterConfigInfo struct {
	Adapter               string `xml:"adapter"`
	CacheLineSize         int    `xml:"cache-line-size"`
	ConnectionEstablished string `xml:"connection-established"`
	DataLinkRate          int    `xml:"data-link-rate"`
	ExternalGbicEnabled   bool   `xml:"external-gbic-enabled"`
	FabricEstablished     bool   `xml:"fabric-established"`
	FirmwareRev           string `xml:"firmware-rev"`
	HardwareRev           string `xml:"hardware-rev"`
	InfoName              string `xml:"info-name"`
	MaxSpeed              int    `xml:"max-speed"`
	MediaType             string `xml:"media-type"`
	MpiFirmwareRev        string `xml:"mpi-firmware-rev"`
	Node                  string `xml:"node"`
	NodeName              string `xml:"node-name"`
	PacketSize            int    `xml:"packet-size"`
	PciBusWidth           int    `xml:"pci-bus-width"`
	PciClockSpeed         int    `xml:"pci-clock-speed"`
	PhyFirmwareRev        string `xml:"phy-firmware-rev"`
	PhysicalDataLinkRate  int    `xml:"physical-data-link-rate"`
	PhysicalLinkState     string `xml:"physical-link-state"`
	PhysicalProtocol      string `xml:"physical-protocol"`
	PortAddress           int    `xml:"port-address"`
	PortName              string `xml:"port-name"`
	Speed                 string `xml:"speed"`
	SramParityEnabled     bool   `xml:"sram-parity-enabled"`
	State                 string `xml:"state"`
	SwitchPort            string `xml:"switch-port"`
	VlanId                int    `xml:"vlan-id"`
}

type FcpAdapterConfigOptions

type FcpAdapterConfigOptions struct {
	DesiredAttributes *FcpAdapterConfigQuery `xml:"desired-attributes,omitempty"`
	MaxRecords        int                    `xml:"max-records,omitempty"`
	Query             *FcpAdapterConfigQuery `xml:"query,omitempty"`
	Tag               string                 `xml:"tag,omitempty"`
}

type FcpAdapterConfigPageHandler

type FcpAdapterConfigPageHandler func(FcpAdapterConfigPageResponse) (shouldContinue bool)

type FcpAdapterConfigPageResponse

type FcpAdapterConfigPageResponse struct {
	Response    *FcpAdapterConfigGetIterResponse
	Error       error
	RawResponse *http.Response
}

type FcpAdapterConfigQuery

type FcpAdapterConfigQuery struct {
	FcpAdapterConfigInfo *FcpAdapterConfigInfo `xml:"net-port-info,omitempty"`
}

type Fcport

type Fcport struct {
	Base
	Params struct {
		XMLName xml.Name
		*FcportGetLinkStateOptions
	}
}

func (*Fcport) GetLinkState

func (f *Fcport) GetLinkState(options *FcportGetLinkStateOptions) (*FcportGetLinkStateResponse, *http.Response, error)

type FcportGetLinkStateOptions

type FcportGetLinkStateOptions struct {
	AdapterName string `xml:"adapter-name,omitempty"`
	NodeName    string `xml:"node-name,omitempty"`
}

type FcportGetLinkStateResponse

type FcportGetLinkStateResponse struct {
	XMLName xml.Name `xml:"netapp"`
	Results struct {
		ResultBase
		AdapterLinkState []FcportLinkStateInfo `xml:"adapter-link-state"`
	} `xml:"results"`
}

type FcportLinkStateInfo

type FcportLinkStateInfo struct {
	AdapterName string `xml:"adapter-name"`
	LinkState   string `xml:"link-state"`
	NodeName    string `xml:"node-name"`
}

type GivebackRelatedInfo

type GivebackRelatedInfo struct {
	GivebackState string `xml:"giveback-state"`
}

type InstanceData

type InstanceData struct {
	Name     string       `xml:"name"`
	Counters PerfCounters `xml:"counters"`
}

type InstanceInfo

type InstanceInfo struct {
	Name string `xml:"name"`
	Uuid string `xml:"uuid"`
}

type InstanceInfoQuery

type InstanceInfoQuery struct {
	InstanceInfo *InstanceInfo `xml:"instance-info,omitempty"`
}

type InterconnectRelatedInfo

type InterconnectRelatedInfo struct {
	InterconnectLinks string `xml:"interconnect-links"`
	InterconnectType  string `xml:"interconnect-type"`
	IsInterconnectUp  bool   `xml:"is-interconnect-up"`
}

type Job

type Job struct {
	Base
	Params struct {
		XMLName xml.Name
		*JobOptions
	}
}

func (*Job) Get

func (q *Job) Get(vserverName string, id int, options *JobOptions) (*JobResponse, *http.Response, error)

func (Job) GetHistory

func (j Job) GetHistory(options *JobHistoryOptions) (*JobListResponse, *http.Response, error)

type JobEntry

type JobEntry struct {
	ID int `xml:"job-id"`
}

type JobHistoryInfo

type JobHistoryInfo struct {
	JobCompletion  string `xml:"job-completion,omitempty"`
	JobDescription string `xml:"job-description,omitempty"`
	JobEndTime     int    `xml:"job-end-time,omitempty"`
	JobEventTime   int    `xml:"job-event-time,omitempty"`
	JobEventType   string `xml:"job-event-type,omitempty"`
	JobID          int    `xml:"job-id,omitempty"`
	JobName        string `xml:"job-name,omitempty"`
	JobNode        string `xml:"job-node,omitempty"`
	JobStartTime   int    `xml:"job-start-time,omitempty"`
	JobStatusCode  int    `xml:"job-status-code,omitempty"`
	JobUsername    string `xml:"job-username,omitempty"`
	JobUUID        string `xml:"job-uuid,omitempty"`
	JobVServer     string `xml:"job-vserver,omitempty"`
	LogID          int    `xml:"log-id,omitempty"`
}

type JobHistoryOptions

type JobHistoryOptions struct {
	Query      *JobHistoryInfo `xml:"query>job-history-info,omitempty"`
	MaxRecords int             `xml:"max-records,omitempty"`
	Tag        string          `xml:"tag,omitempty"`
}

type JobListResponse

type JobListResponse struct {
	XMLName xml.Name `xml:"netapp"`
	Results struct {
		ResultBase
		HistoryInfo []JobHistoryInfo `xml:"attributes-list>job-history-info"`
		NumRecords  int              `xml:"num-records"`
	} `xml:"results"`
}

type JobOptions

type JobOptions struct {
	DesiredAttributes *JobEntry `xml:"desired-attributes,omitempty"`
	MaxRecords        int       `xml:"max-records,omitempty"`
	Tag               string    `xml:"tag,omitempty"`
	*JobEntry
}

type JobResponse

type JobResponse struct {
	XMLName xml.Name `xml:"netapp"`
	Results struct {
		ResultBase
		Attributes struct {
			JobInfo struct {
				IsRestarted              string `xml:"is-restarted"`
				JobAffinity              string `xml:"job-affinity"`
				JobCategory              string `xml:"job-category"`
				JobCompletion            string `xml:"job-completion"`
				JobDescription           string `xml:"job-description"`
				JobID                    string `xml:"job-id"`
				JobName                  string `xml:"job-name"`
				JobNode                  string `xml:"job-node"`
				JobPriority              string `xml:"job-priority"`
				JobProcess               string `xml:"job-process"`
				JobProgress              string `xml:"job-progress"`
				JobQueueTime             string `xml:"job-queue-time"`
				JobRestartIsOrWasDelayed string `xml:"job-restart-is-or-was-delayed"`
				JobSchedule              string `xml:"job-schedule"`
				JobStartTime             string `xml:"job-start-time"`
				JobState                 string `xml:"job-state"`
				JobStatusCode            string `xml:"job-status-code"`
				JobType                  string `xml:"job-type"`
				JobUsername              string `xml:"job-username"`
				JobUUID                  string `xml:"job-uuid"`
				JobVserver               string `xml:"job-vserver"`
			} `xml:"job-info"`
		} `xml:"attributes"`
	} `xml:"results"`
}

func (*JobResponse) JobState

func (j *JobResponse) JobState() string

func (*JobResponse) Success

func (j *JobResponse) Success() bool

type Lun

type Lun struct {
	Base
	Params struct {
		XMLName xml.Name
		*LunOptions
	}
}

func (*Lun) List

func (v *Lun) List(options *LunOptions) (*LunListResponse, *http.Response, error)

func (*Lun) ListPages

func (v *Lun) ListPages(options *LunOptions, fn LunPageHandler)

type LunInfo

type LunInfo struct {
	Alignment                 string `xml:"alignment"`
	BackingSnapshot           string `xml:"backing-snapshot"`
	BlockSize                 int    `xml:"block-size"`
	Class                     string `xml:"class"`
	CloneBackingSnapshot      string `xml:"clone-backing-snapshot"`
	Comment                   string `xml:"comment"`
	CreationTimestamp         int    `xml:"creation-timestamp"`
	DeviceBinaryId            string `xml:"device-binary-id"`
	DeviceId                  int    `xml:"device-id"`
	DeviceTextId              string `xml:"device-text-id"`
	IsClone                   bool   `xml:"is-clone"`
	IsCloneAutodeleteEnabled  bool   `xml:"is-clone-autodelete-enabled"`
	IsInconsistentImport      bool   `xml:"is-inconsistent-import"`
	IsRestoreInaccessible     bool   `xml:"is-restore-inaccessible"`
	IsSpaceAllocEnabled       bool   `xml:"is-space-alloc-enabled"`
	IsSpaceReservationEnabled bool   `xml:"is-space-reservation-enabled"`
	Mapped                    bool   `xml:"mapped"`
	MultiprotocolType         string `xml:"multiprotocol-type"`
	Node                      string `xml:"node"`
	Online                    bool   `xml:"online"`
	Path                      string `xml:"path"`
	PrefixSize                int    `xml:"prefix-size"`
	QosPolicyGroup            string `xml:"qos-policy-group"`
	Qtree                     string `xml:"qtree"`
	ReadOnly                  bool   `xml:"read-only"`
	Serial7Mode               string `xml:"serial-7-mode"`
	SerialNumber              string `xml:"serial-number"`
	ShareState                string `xml:"share-state"`
	Size                      int    `xml:"size"`
	SizeUsed                  int    `xml:"size-used"`
	Staging                   bool   `xml:"staging"`
	State                     string `xml:"state"`
	SuffixSize                int    `xml:"suffix-size"`
	Uuid                      string `xml:"uuid"`
	Volume                    string `xml:"volume"`
	Vserver                   string `xml:"vserver"`
}

type LunListPagesResponse

type LunListPagesResponse struct {
	Response    *LunListResponse
	Error       error
	RawResponse *http.Response
}

type LunListResponse

type LunListResponse struct {
	XMLName xml.Name `xml:"netapp"`
	Results struct {
		ResultBase
		AttributesList struct {
			LunAttributes []LunInfo `xml:"lun-info"`
		} `xml:"attributes-list"`
		NextTag    string `xml:"next-tag"`
		NumRecords int    `xml:"num-records"`
	} `xml:"results"`
}

type LunOptions

type LunOptions struct {
	DesiredAttributes *LunQuery `xml:"desired-attributes,omitempty"`
	MaxRecords        int       `xml:"max-records,omitempty"`
	Query             *LunQuery `xml:"query,omitempty"`
	Tag               string    `xml:"tag,omitempty"`
}

type LunPageHandler

type LunPageHandler func(LunListPagesResponse) (shouldContinue bool)

type LunQuery

type LunQuery struct {
	LunInfo *LunInfo `xml:"lun-info,omitempty"`
}

type Net

type Net struct {
	Base
}

func (Net) CreateBroadcastDomain

func (n Net) CreateBroadcastDomain(createOptions *NetBroadcastDomainCreateOptions) (*NetBroadcastDomainCreateResponse, *http.Response, error)

CreateBroadcastDomain creates a new broadcast domain

func (Net) CreateIPSpace

func (n Net) CreateIPSpace(name string, returnRecord bool) (*NetIPSpaceResponse, *http.Response, error)

CreateIPSpace creates a new ipspace on the cluster

func (Net) CreateNetInterface

func (n Net) CreateNetInterface(options *NetInterfaceInfo) (*SingleResultResponse, *http.Response, error)

CreateNetInterface creates a new network interface

func (Net) CreateRoute

func (n Net) CreateRoute(vServerName string, options *NetRoutesInfo) (*NetRoutesResponse, *http.Response, error)

CreateRoute creates a new route for Routing Group

func (Net) CreateVlan

func (n Net) CreateVlan(options *NetVlanInfo) (*SingleResultResponse, *http.Response, error)

CreateVlan creates a new vlan

func (Net) DeleteBroadcastDomain

func (n Net) DeleteBroadcastDomain(domain string, ipSpace string) (*NetBroadcastDomainCreateResponse, *http.Response, error)

func (Net) DeleteIPSpace

func (n Net) DeleteIPSpace(name string) (*NetIPSpaceResponse, *http.Response, error)

DeleteIPSpace deletes an IPSpace

func (Net) DeleteNetInterface

func (n Net) DeleteNetInterface(vServerName string, lif string) (*SingleResultResponse, *http.Response, error)

DeleteNetInterface removes a LIF from a vserver

func (Net) DeleteRoute

func (n Net) DeleteRoute(vServerName string, destination string, gateway string) (*SingleResultResponse, *http.Response, error)

DeleteRoute creates a new route for Routing Group

func (Net) DeleteVlan

func (n Net) DeleteVlan(options *NetVlanInfo) (*SingleResultResponse, *http.Response, error)

DeleteVlan removes vlan from existence

func (Net) GetBroadcastDomain

func (n Net) GetBroadcastDomain(domain string, ipSpace string) (*NetBroadcastDomainResponse, *http.Response, error)

GetBroadcastDomain grabs a single named broadcast domain

func (Net) GetIPSpace

func (n Net) GetIPSpace(name string) (*NetIPSpaceResponse, *http.Response, error)

GetIPSpace grabs data for an ip space

func (Net) GetVlan

func (n Net) GetVlan(interfaceName string, node string) (*NetVlanResponse, *http.Response, error)

GetVlan grabs a single named broadcast domain

func (Net) ListIPSpaces

func (n Net) ListIPSpaces(query *NetIPSpaceInfo) (*NetIPSpaceListResponse, *http.Response, error)

func (Net) ListVlans

func (n Net) ListVlans(info *NetVlanInfo) (*NetVlanListResponse, *http.Response, error)

ListVlans lists all vlans that match info query

func (*Net) NetInterfaceGetAll

func (n *Net) NetInterfaceGetAll(options *NetInterfaceOptions, fn NetInterfacePageHandler)

func (*Net) NetInterfaceGetIter

func (n *Net) NetInterfaceGetIter(options *NetInterfaceOptions) (*NetInterfaceGetIterResponse, *http.Response, error)

func (*Net) NetPortGetAll

func (n *Net) NetPortGetAll(options *NetPortOptions, fn NetPortPageHandler)

func (*Net) NetPortGetIter

func (n *Net) NetPortGetIter(options *NetPortOptions) (*NetPortGetIterResponse, *http.Response, error)

func (Net) RenameIPSpace

func (n Net) RenameIPSpace(name string, newName string) (*NetIPSpaceResponse, *http.Response, error)

RenameIPSpace changes the name of an ipspace

type NetBroadcastDomainCreateOptions

type NetBroadcastDomainCreateOptions struct {
	BroadcastDomain string    `xml:"broadcast-domain"`
	IPSpace         string    `xml:"ipspace"`
	MTU             int       `xml:"mtu,omitempty"`
	Ports           *[]string `xml:"ports>net-qualified-port-name,omitempty"`
}

NetBroadcastDomainCreateOptions used for creating new Broadcast Domain

type NetBroadcastDomainCreateResponse

type NetBroadcastDomainCreateResponse struct {
	XMLName xml.Name `xml:"netapp"`
	Results struct {
		SingleResultBase
		CombinedPortUpdateStatus string `xml:"port-update-status-combined"`
	} `xml:"results"`
}

NetBroadcastDomainCreateResponse returns result of creating a new broadcast domain

type NetBroadcastDomainInfo

type NetBroadcastDomainInfo struct {
	BroadcastDomain          string               `xml:"broadcast-domain,omitempty"`
	FailoverGroups           []string             `xml:"failover-groups>failover-group"`
	IPSpace                  string               `xml:"ipspace,omitempty"`
	MTU                      int                  `xml:"mtu,omitempty"`
	CombinedPortUpdateStatus string               `xml:"port-update-status-combined,omitempty"`
	Ports                    *[]NetPortUpdateInfo `xml:"ports>port-info"`
	SubnetNames              []string             `xml:"subnet-names>subnet-name"`
}

NetBroadcastDomainInfo is the Broadcast Domain data

type NetBroadcastDomainOptions

type NetBroadcastDomainOptions struct {
	DesiredAttributes *NetBroadcastDomainInfo `xml:"desired-attributes,omitempty"`
	MaxRecords        int                     `xml:"max-records,omitempty"`
	Query             *NetBroadcastDomainInfo `xml:"query,omitempty"`
	Tag               string                  `xml:"tag,omitempty"`
}

NetBroadcastDomainOptions get/list options for getting broadcast domains

type NetBroadcastDomainResponse

type NetBroadcastDomainResponse struct {
	XMLName xml.Name `xml:"netapp"`
	Results struct {
		SingleResultBase
		Info NetBroadcastDomainInfo `xml:"attributes>net-port-broadcast-domain-info"`
	} `xml:"results"`
}

NetBroadcastDomainResponse returns results for broadcast domains

type NetIPSpaceInfo

type NetIPSpaceInfo struct {
	BroadcastDomains *[]string `xml:"broadcast-domains>broadcast-domain-name,omitempty"`
	ID               int       `xml:"id,omitempty"`
	IPSpace          string    `xml:"ipspace,omitempty"`
	Ports            *[]string `xml:"ports>net-qualified-port-name,omitempty"`
	UUID             string    `xml:"uuid,omitempty"`
	VServers         *[]string `xml:"vservers>vserver-name,omitempty"`
}

NetIPSpaceInfo holds newly created ipspace variables

type NetIPSpaceListResponse

type NetIPSpaceListResponse struct {
	XMLName xml.Name `xml:"netapp"`
	Results struct {
		ResultBase
		Info       []NetIPSpaceInfo `xml:"attributes-list>net-ipspaces-info"`
		NumRecords string           `xml:"num-records"`
	} `xml:"results"`
}

type NetIPSpaceOptions

type NetIPSpaceOptions struct {
	DesiredAttributes *NetIPSpaceInfo `xml:"desired-attributes>net-ip-spaces-info,omitempty"`
	MaxRecords        int             `xml:"max-records,omitempty"`
	Query             *NetIPSpaceInfo `xml:"query>net-ipspaces-info,omitempty"`
	Tag               string          `xml:"tag,omitempty"`
}

type NetIPSpaceResponse

type NetIPSpaceResponse struct {
	XMLName xml.Name `xml:"netapp"`
	Results struct {
		SingleResultBase
		NetIPSpaceInfo       `xml:",innerxml"`
		NetIPSpaceCreateInfo *NetIPSpaceInfo `xml:"result>net-ipspaces-info"`
	} `xml:"results"`
}

NetIPSpaceResponse is return type for net ip space requests

type NetInterfaceGetIterResponse

type NetInterfaceGetIterResponse struct {
	XMLName xml.Name `xml:"netapp"`
	Results struct {
		ResultBase
		AttributesList struct {
			NetInterfaceAttributes []NetInterfaceInfo `xml:"net-interface-info"`
		} `xml:"attributes-list"`
		NextTag    string `xml:"next-tag"`
		NumRecords int    `xml:"num-records"`
	} `xml:"results"`
}

type NetInterfaceInfo

type NetInterfaceInfo struct {
	Address              string    `xml:"address,omitempty"`
	AdministrativeStatus string    `xml:"administrative-status,omitempty"`
	Comment              string    `xml:"comment,omitempty"`
	DataProtocols        *[]string `xml:"data-protocols>data-protocol"`
	CurrentNode          string    `xml:"current-node,omitempty"`
	CurrentPort          string    `xml:"current-port,omitempty"`
	DnsDomainName        string    `xml:"dns-domain-name,omitempty"`
	FailoverGroup        string    `xml:"failover-group,omitempty"`
	FailoverPolicy       string    `xml:"failover-policy,omitempty"`
	FirewallPolicy       string    `xml:"firewall-policy,omitempty"`
	HomeNode             string    `xml:"home-node,omitempty"`
	HomePort             string    `xml:"home-port,omitempty"`
	InterfaceName        string    `xml:"interface-name,omitempty"`
	IsAutoRevert         bool      `xml:"is-auto-revert,omitempty"`
	IsHome               bool      `xml:"is-home,omitempty"`
	IsIpv4LinkLocal      bool      `xml:"is-ipv4-link-local,omitempty"`
	Netmask              string    `xml:"netmask,omitempty"`
	NetmaskLength        int       `xml:"netmask-length,omitempty"`
	OperationalStatus    string    `xml:"operational-status,omitempty"`
	Role                 string    `xml:"role,omitempty"`
	RoutingGroupName     string    `xml:"routing-group-name,omitempty"`
	UseFailoverGroup     string    `xml:"use-failover-group,omitempty"`
	Vserver              string    `xml:"vserver,omitempty"`
}

type NetInterfaceOptions

type NetInterfaceOptions struct {
	DesiredAttributes *NetInterfaceQuery `xml:"desired-attributes,omitempty"`
	MaxRecords        int                `xml:"max-records,omitempty"`
	Query             *NetInterfaceQuery `xml:"query,omitempty"`
	Tag               string             `xml:"tag,omitempty"`
}

type NetInterfacePageHandler

type NetInterfacePageHandler func(NetInterfacePageResponse) (shouldContinue bool)

type NetInterfacePageResponse

type NetInterfacePageResponse struct {
	Response    *NetInterfaceGetIterResponse
	Error       error
	RawResponse *http.Response
}

type NetInterfaceQuery

type NetInterfaceQuery struct {
	NetInterfaceInfo *NetInterfaceInfo `xml:"net-interface-info,omitempty"`
}

type NetPortGetIterResponse

type NetPortGetIterResponse struct {
	XMLName xml.Name `xml:"netapp"`
	Results struct {
		ResultBase
		AttributesList struct {
			NetPortAttributes []NetPortInfo `xml:"net-port-info"`
		} `xml:"attributes-list"`
		NextTag    string `xml:"next-tag"`
		NumRecords int    `xml:"num-records"`
	} `xml:"results"`
}

type NetPortInfo

type NetPortInfo struct {
	AdministrativeDuplex          string `xml:"administrative-duplex,omitempty"`
	AdministrativeFlowcontrol     string `xml:"administrative-flowcontrol,omitempty"`
	AdministrativeSpeed           string `xml:"administrative-speed,omitempty"`
	AutorevertDelay               int    `xml:"autorevert-delay,omitempty"`
	IfgrpDistributionFunction     string `xml:"ifgrp-distribution-function,omitempty"`
	IfgrpMode                     string `xml:"ifgrp-mode,omitempty"`
	IfgrpNode                     string `xml:"ifgrp-node,omitempty"`
	IfgrpPort                     string `xml:"ifgrp-port,omitempty"`
	IsAdministrativeAutoNegotiate bool   `xml:"is-administrative-auto-negotiate,omitempty"`
	IsAdministrativeUp            bool   `xml:"is-administrative-up,omitempty"`
	IsOperationalAutoNegotiate    bool   `xml:"is-operational-auto-negotiate,omitempty"`
	LinkStatus                    string `xml:"link-status,omitempty"`
	MacAddress                    string `xml:"mac-address,omitempty"`
	Mtu                           int    `xml:"mtu,omitempty"`
	Node                          string `xml:"node,omitempty"`
	OperationalDuplex             string `xml:"operational-duplex,omitempty"`
	OperationalFlowcontrol        string `xml:"operational-flowcontrol,omitempty"`
	OperationalSpeed              string `xml:"operational-speed,omitempty"`
	Port                          string `xml:"port,omitempty"`
	PortType                      string `xml:"port-type,omitempty"`
	RemoteDeviceId                string `xml:"remote-device-id,omitempty"`
	Role                          string `xml:"role,omitempty"`
	VlanId                        int    `xml:"vlan-id,omitempty"`
	VlanNode                      string `xml:"vlan-node,omitempty"`
	VlanPort                      string `xml:"vlan-port,omitempty"`
}

type NetPortOptions

type NetPortOptions struct {
	DesiredAttributes *NetPortQuery `xml:"desired-attributes,omitempty"`
	MaxRecords        int           `xml:"max-records,omitempty"`
	Query             *NetPortQuery `xml:"query,omitempty"`
	Tag               string        `xml:"tag,omitempty"`
}

type NetPortPageHandler

type NetPortPageHandler func(NetPortPageResponse) (shouldContinue bool)

type NetPortPageResponse

type NetPortPageResponse struct {
	Response    *NetPortGetIterResponse
	Error       error
	RawResponse *http.Response
}

type NetPortQuery

type NetPortQuery struct {
	NetPortInfo *NetPortInfo `xml:"net-port-info,omitempty"`
}

type NetPortUpdateInfo

type NetPortUpdateInfo struct {
	Port                    string `xml:"port"`
	PortUpdateStatus        string `xml:"port-update-status"`
	PortUpdateStatusDetails string `xml:"port-update-status-details"`
}

NetPortUpdateInfo is port info for the broadcast domain

type NetRoutesInfo

type NetRoutesInfo struct {
	AddressFamily      string `xml:"address-family,omitempty"`
	DestinationAddress string `xml:"destination"`
	GatewayAddress     string `xml:"gateway"`
	Metric             int    `xml:"metric,omitempty"`
	ReturnRecord       bool   `xml:"return-record,omitempty"`
	VServer            string `xml:"vserver,omitempty"`
}

NetRoutingGroupRouteInfo holds route information

type NetRoutesResponse

type NetRoutesResponse struct {
	XMLName xml.Name `xml:"netapp"`
	Results struct {
		SingleResultBase
		Info NetRoutesInfo `xml:"result>net-vs-routes-info"`
	} `xml:"results"`
}

type NetVlanInfo

type NetVlanInfo struct {
	InterfaceName   string `xml:"interface-name,omitempty"`
	Node            string `xml:"node,omitempty"`
	ParentInterface string `xml:"parent-interface,omitempty"`
	VlanID          int    `xml:"vlanid,omitempty"`
}

NetVlanInfo is the Vlan data

func (*NetVlanInfo) ToString

func (v *NetVlanInfo) ToString() string

ToString converts to string, ie test-cluster-01-01:a0a-3555

type NetVlanListResponse

type NetVlanListResponse struct {
	XMLName xml.Name `xml:"netapp"`
	Results struct {
		ResultBase
		Info []NetVlanInfo `xml:"attributes-list>vlan-info"`
	} `xml:"results"`
}

NetVlanListResponse returns results for a list of vlans

type NetVlanOptions

type NetVlanOptions struct {
	DesiredAttributes *NetVlanInfo `xml:"desired-attributes>vlan-info,omitempty"`
	MaxRecords        int          `xml:"max-records,omitempty"`
	Query             *NetVlanInfo `xml:"query>vlan-info,omitempty"`
	Tag               string       `xml:"tag,omitempty"`
}

NetVlanOptions get/list options for getting vlans

type NetVlanResponse

type NetVlanResponse struct {
	XMLName xml.Name `xml:"netapp"`
	Results struct {
		SingleResultBase
		Info NetVlanInfo `xml:"attributes>vlan-info"`
	} `xml:"results"`
}

NetVlanResponse returns results for a single vlan

type NodeDetailOptions

type NodeDetailOptions struct {
	DesiredAttributes *NodeDetailsQuery `xml:"desired-attributes,omitempty"`
	MaxRecords        int               `xml:"max-records,omitempty"`
	Query             *NodeDetailsQuery `xml:"query,omitempty"`
	Tag               string            `xml:"tag,omitempty"`
}

type NodeDetails

type NodeDetails struct {
	EnvFailedFanCount           int    `xml:"env-failed-fan-count"`
	EnvFailedFanMessage         string `xml:"env-failed-fan-message"`
	EnvFailedPowerSupplyCount   int    `xml:"env-failed-power-supply-count"`
	EnvFailedPowerSupplyMessage string `xml:"env-failed-power-supply-message"`
	EnvOverTemperature          bool   `xml:"env-over-temperature"`
	Name                        string `xml:"node"`
	NodeAssetTag                string `xml:"node-asset-tag"`
	NodeLocation                string `xml:"node-location"`
	NodeModel                   string `xml:"node-model"`
	NodeNvramId                 string `xml:"node-nvram-id"`
	NodeOwner                   string `xml:"node-owner"`
	NodeSerialNumber            string `xml:"node-serial-number"`
	NodeStorageConfiguration    string `xml:"node-storage-configuration"`
	NodeSystemId                string `xml:"node-system-id"`
	NodeUptime                  string `xml:"node-uptime"`
	NodeUuid                    string `xml:"node-uuid"`
	NodeVendor                  string `xml:"node-vendor"`
	NvramBatteryStatus          string `xml:"nvram-battery-status"`
	ProductVersion              string `xml:"product-version"`
}

type NodeDetailsPageHandler

type NodeDetailsPageHandler func(NodeDetailsPagesResponse) (shouldContinue bool)

type NodeDetailsPagesResponse

type NodeDetailsPagesResponse struct {
	Response    *NodeDetailsResponse
	Error       error
	RawResponse *http.Response
}

type NodeDetailsQuery

type NodeDetailsQuery struct {
	NodeDetails *NodeDetails `xml:"node-details-info,omitempty"`
}

type NodeDetailsResponse

type NodeDetailsResponse struct {
	XMLName xml.Name `xml:"netapp"`
	Results struct {
		ResultBase
		NodeDetails []NodeDetails `xml:"attributes-list>node-details-info"`
		NextTag     string        `xml:"next-tag"`
		NumRecords  int           `xml:"num-records"`
	} `xml:"results"`
}

type NodeRelatedInfo

type NodeRelatedInfo struct {
	CurrentMode             string `xml:"current-mode"`
	LocalFirmwareProgress   int    `xml:"local-firmware-progress"`
	LocalFirmwareState      string `xml:"local-firmware-state"`
	Node                    string `xml:"node"`
	NodeState               string `xml:"node-state"`
	NvramId                 int    `xml:"nvram-id"`
	PartnerFirmwareProgress int    `xml:"partner-firmware-progress"`
	PartnerFirmwareState    string `xml:"partner-firmware-state"`
	PartnerName             string `xml:"partner-name"`
	PartnerNvramId          int    `xml:"partner-nvram-id"`
	StateDescription        string `xml:"state-description"`
}

type Perf

type Perf struct {
	Base
}

func (*Perf) PerfObjectGetInstances

func (p *Perf) PerfObjectGetInstances(params *PerfObjectGetInstanceParams) (*PerfObjectGetInstancesResponse, *http.Response, error)

func (*Perf) PerfObjectInstanceGetAllInfo

func (p *Perf) PerfObjectInstanceGetAllInfo(options *PerfObjectInstanceListInfoIterParams, fn PerfObjectInstanceListInfoHandler)

func (*Perf) PerfObjectInstanceListInfoIter

func (p *Perf) PerfObjectInstanceListInfoIter(params *PerfObjectInstanceListInfoIterParams) (*PerfObjectInstanceListInfoIterResponse, *http.Response, error)

type PerfCounterData

type PerfCounterData struct {
	Name  string `xml:"name"`
	Value string `xml:"value"`
}

type PerfCounters

type PerfCounters struct {
	CounterData []PerfCounterData `xml:"counter-data"`
}

type PerfObjectGetInstanceParams

type PerfObjectGetInstanceParams struct {
	ObjectName    string `xml:"objectname"`
	InstanceUuids struct {
		Uuids []string `xml:"instance-uuid"`
	} `xml:"instance-uuids,omitempty"`
	Instances struct {
		Instances []string `xml:"instance"`
	} `xml:"instances,omitempty"`
	Counters struct {
		Counter []string `xml:"counter"`
	} `xml:"counters"`
}

type PerfObjectGetInstancesResponse

type PerfObjectGetInstancesResponse struct {
	XMLName xml.Name `xml:"netapp"`
	Results struct {
		ResultBase
		PerfObjectInstanceData PerfObjectInstanceData `xml:"instances"`
	} `xml:"results"`
}

type PerfObjectInstanceData

type PerfObjectInstanceData struct {
	Instances []InstanceData `xml:"instance-data"`
}

type PerfObjectInstanceListInfoHandler

type PerfObjectInstanceListInfoHandler func(PerfObjectInstanceListInfoPageResponse) (shouldContinue bool)

type PerfObjectInstanceListInfoIterParams

type PerfObjectInstanceListInfoIterParams struct {
	DesiredAttributes *InstanceInfo      `xml:"desired-attributes,omitempty"`
	FilterData        string             `xml:"filter-data,omitempty"`
	MaxRecords        int                `xml:"max-records,omitempty"`
	ObjectName        string             `xml:"objectname"`
	Query             *InstanceInfoQuery `xml:"query,omitempty"`
	Tag               string             `xml:"tag,omitempty"`
}

type PerfObjectInstanceListInfoIterResponse

type PerfObjectInstanceListInfoIterResponse struct {
	XMLName xml.Name `xml:"netapp"`
	Results struct {
		ResultBase
		AttributesList struct {
			InstanceInfo []InstanceInfo `xml:"instance-info"`
		} `xml:"attributes-list"`
		NextTag    string `xml:"next-tag"`
		NumRecords int    `xml:"num-records"`
	} `xml:"results"`
}

type PerfObjectInstanceListInfoPageResponse

type PerfObjectInstanceListInfoPageResponse struct {
	Response    *PerfObjectInstanceListInfoIterResponse
	Error       error
	RawResponse *http.Response
}

type QosPolicy

type QosPolicy struct {
	Base
	Params struct {
		XMLName xml.Name
		Query   *QosPolicyInfo `xml:"desired-attributes,omitempty"`
		QosPolicyInfo
		QosPolicyRenameInfo
	}
}

QosPolicy is the main struct we're building on

func (QosPolicy) ChangeIops

func (qp QosPolicy) ChangeIops(iops string, qosPolicyName string) (*QosPolicyResponse, *http.Response, error)

ChangeIops modifies the iops

func (QosPolicy) Create

func (qp QosPolicy) Create(query *QosPolicyInfo) (*QosPolicyResponse, *http.Response, error)

Create makes new qos policy

func (QosPolicy) Delete

func (qp QosPolicy) Delete(name string, force bool) (*QosPolicyResponse, *http.Response, error)

Delete removes qos policy from the cluster, optionally forcing that deletion

func (QosPolicy) Get

func (qp QosPolicy) Get(name string, query *QosPolicyInfo) (*QosPolicyResponse, *http.Response, error)

Get grabs a qos policy, note: it will do so cluster wide

func (QosPolicy) Rename

func (qp QosPolicy) Rename(info *QosPolicyRenameInfo) (*QosPolicyResponse, *http.Response, error)

Rename changes policy name, any volumes attached to the policy get the new name automatically

type QosPolicyInfo

type QosPolicyInfo struct {
	MaxThroughput    string `xml:"max-throughput,omitempty"`
	NumWorkloads     int    `xml:"num-workloads,omitempty"`
	PgID             int    `xml:"pgid,omitempty"`
	PolicyGroup      string `xml:"policy-group,omitempty"`
	PolicyGroupClass string `xml:"policy-group-class,omitempty"`
	UUID             string `xml:"uuid,omitempty"`
	VServer          string `xml:"vserver,omitempty"`
	// ReturnRecord is only used in create
	ReturnRecord bool `xml:"return-record,omitempty"`
	// Force is only used in delete
	Force bool `xml:"force,omitempty"`
}

QosPolicyInfo is all qos policy data netapp stores

type QosPolicyRenameInfo

type QosPolicyRenameInfo struct {
	CurrentPolicyGroup string `xml:"policy-group-name,omitempty"`
	NewPolicyGroup     string `xml:"new-name,omitempty"`
}

QosPolicyRenameInfo is a struct for renaming a qos policy

type QosPolicyResponse

type QosPolicyResponse struct {
	XMLName xml.Name `xml:"netapp"`
	Results struct {
		SingleResultBase
		QosPolicyInfo QosPolicyInfo `xml:"attributes>qos-policy-group-info"`
	} `xml:"results"`
}

QosPolicyResponse is what comes back from the api

type Qtree

type Qtree struct {
	Base
	Params struct {
		XMLName xml.Name
		*QtreeOptions
	}
}

func (*Qtree) Create

func (q *Qtree) Create(vserverName, volume, qtree string, info *QtreeInfo) (*QtreeListResponse, *http.Response, error)

func (*Qtree) Delete

func (q *Qtree) Delete(vserverName, volName, qtreeName string, force bool) (*QtreeListResponse, *http.Response, error)

func (*Qtree) DeleteAsync

func (q *Qtree) DeleteAsync(vserverName, volName, qtreeName string) (*QtreeListResponse, *http.Response, error)

func (*Qtree) List

func (q *Qtree) List(options *QtreeOptions) (*QtreeListResponse, *http.Response, error)

type QtreeInfo

type QtreeInfo struct {
	ExportPolicy            string `xml:"export-policy,omitempty"`
	ID                      string `xml:"id,omitempty"`
	IsExportPolicyInherited string `xml:"is-export-policy-inherited,omitempty"`
	Mode                    string `xml:"mode,omitempty"`
	Oplocks                 string `xml:"oplocks,omitempty"`
	Qtree                   string `xml:"qtree,omitempty"`
	Force                   bool   `xml:"force,omitempty"`
	SecurityStyle           string `xml:"security-style,omitempty"`
	Status                  string `xml:"status,omitempty"`
	Volume                  string `xml:"volume,omitempty"`
	Vserver                 string `xml:"vserver,omitempty"`
}

type QtreeListResponse

type QtreeListResponse struct {
	XMLName xml.Name `xml:"netapp"`
	Results struct {
		ResultBase
		AttributesList struct {
			QtreeInfo []QtreeInfo `xml:"qtree-info"`
		} `xml:"attributes-list"`
	} `xml:"results"`
	ResultJobid  string `xml:"result-jobid"`
	ResultStatus string `xml:"result-status"`
}

type QtreeOptions

type QtreeOptions struct {
	DesiredAttributes *QtreeQuery `xml:"desired-attributes,omitempty"`
	MaxRecords        int         `xml:"max-records,omitempty"`
	Query             *QtreeQuery `xml:"query,omitempty"`
	Tag               string      `xml:"tag,omitempty"`
	*QtreeInfo
}

type QtreeQuery

type QtreeQuery struct {
	QtreeInfo *QtreeInfo `xml:"qtree-info,omitempty"`
}

type Quota

type Quota struct {
	Base
	Params struct {
		XMLName xml.Name
		*QuotaOptions
	}
}

func (*Quota) Create

func (q *Quota) Create(serverName, target, quotaType, qtree string, entry *QuotaEntry) (*QuotaListResponse, *http.Response, error)

func (*Quota) Delete

func (q *Quota) Delete(serverName, target, quotaType, volume, qtree string) (*QuotaListResponse, *http.Response, error)

func (*Quota) Get

func (q *Quota) Get(name string, options *QuotaOptions) (*QuotaResponse, *http.Response, error)

func (*Quota) List

func (q *Quota) List(options *QuotaOptions) (*QuotaListResponse, *http.Response, error)

func (*Quota) Off

func (q *Quota) Off(serverName, volumeName string) (*QuotaStatusResponse, *http.Response, error)

func (*Quota) On

func (q *Quota) On(serverName, volumeName string) (*QuotaStatusResponse, *http.Response, error)

func (*Quota) Status

func (q *Quota) Status(serverName, volumeName string) (*QuotaStatusResponse, *http.Response, error)

func (*Quota) Update

func (q *Quota) Update(serverName string, entry *QuotaEntry) (*QuotaListResponse, *http.Response, error)

type QuotaEntry

type QuotaEntry struct {
	DiskLimit          string  `xml:"disk-limit,omitempty"`
	FileLimit          string  `xml:"file-limit,omitempty"`
	PerformUserMapping string  `xml:"perform-user-mapping,omitempty"`
	Policy             string  `xml:"policy,omitempty"`
	Qtree              *string `xml:"qtree,omitempty"`
	QuotaTarget        string  `xml:"quota-target,omitempty"`
	QuotaType          string  `xml:"quota-type,omitempty"`
	SoftDiskLimit      string  `xml:"soft-disk-limit,omitempty"`
	SoftFileLimit      string  `xml:"soft-file-limit,omitempty"`
	Threshold          string  `xml:"threshold,omitempty"`
	Volume             string  `xml:"volume,omitempty"`
	Vserver            string  `xml:"vserver,omitempty"`
}

type QuotaListResponse

type QuotaListResponse struct {
	XMLName xml.Name `xml:"netapp"`
	Results struct {
		ResultBase
		AttributesList struct {
			QuotaEntry []QuotaEntry `xml:"quota-entry"`
		} `xml:"attributes-list"`
	} `xml:"results"`
}

type QuotaOptions

type QuotaOptions struct {
	DesiredAttributes *QuotaQuery `xml:"desired-attributes,omitempty"`
	MaxRecords        int         `xml:"max-records,omitempty"`
	Query             *QuotaQuery `xml:"query,omitempty"`
	Tag               string      `xml:"tag,omitempty"`
	*QuotaEntry
}

type QuotaQuery

type QuotaQuery struct {
	QuotaEntry *QuotaEntry `xml:"quota-entry,omitempty"`
}

type QuotaReport

type QuotaReport struct {
	Base
	Params struct {
		XMLName xml.Name
		*QuotaReportOptions
	}
}

func (*QuotaReport) Report

func (qr *QuotaReport) Report(options *QuotaReportOptions) (*QuotaReportResponse, *http.Response, error)

func (*QuotaReport) ReportPages

func (a *QuotaReport) ReportPages(options *QuotaReportOptions, fn QuotaReportPageHandler)

type QuotaReportEntry

type QuotaReportEntry struct {
	DiskLimit     string `xml:"disk-limit,omitempty"`
	DiskUsed      string `xml:"disk-used,omitempty"`
	FileLimit     string `xml:"file-limit,omitempty"`
	FilesUsed     string `xml:"files-used,omitempty"`
	QuotaTarget   string `xml:"quota-target,omitempty"`
	QuotaType     string `xml:"quota-type,omitempty"`
	SoftDiskLimit string `xml:"soft-disk-limit,omitempty"`
	SoftFileLimit string `xml:"soft-file-limit,omitempty"`
	Threshold     string `xml:"threshold,omitempty"`
	Tree          string `xml:"tree,omitempty"`
	Volume        string `xml:"volume,omitempty"`
	Vserver       string `xml:"vserver,omitempty"`
}

type QuotaReportEntryQuery

type QuotaReportEntryQuery struct {
	QuotaReportEntry *QuotaReportEntry `xml:"quota,omitempty"`
}

type QuotaReportOptions

type QuotaReportOptions struct {
	DesiredAttributes *QuotaReportEntryQuery `xml:"desired-attributes,omitempty"`
	MaxRecords        int                    `xml:"max-records,omitempty"`
	Path              string                 `xml:"path,omitempty"`
	Query             *QuotaReportEntryQuery `xml:"query,omitempty"`
	Tag               string                 `xml:"tag,omitempty"`
}

type QuotaReportPageHandler

type QuotaReportPageHandler func(QuotaReportPagesResponse) (shouldContinue bool)

type QuotaReportPagesResponse

type QuotaReportPagesResponse struct {
	Response    *QuotaReportResponse
	Error       error
	RawResponse *http.Response
}

type QuotaReportResponse

type QuotaReportResponse struct {
	XMLName xml.Name `xml:"netapp"`
	Results struct {
		ResultBase
		AttributesList struct {
			QuotaReportEntry []QuotaReportEntry `xml:"quota"`
		} `xml:"attributes-list"`
		NextTag    string `xml:"next-tag"`
		NumRecords int    `xml:"num-records"`
	} `xml:"results"`
}

type QuotaResponse

type QuotaResponse struct {
	XMLName xml.Name `xml:"netapp"`
	Results struct {
		ResultBase
		QuotaEntry
	} `xml:"results"`
}

type QuotaStatus

type QuotaStatus struct {
	Base
	Params struct {
		XMLName xml.Name
		*QuotaStatusIterOptions
	}
}

func (*QuotaStatus) StatusIter

func (qr *QuotaStatus) StatusIter(options *QuotaStatusIterOptions) (*QuotaStatusIterResponse, *http.Response, error)

func (*QuotaStatus) StatusPages

func (a *QuotaStatus) StatusPages(options *QuotaStatusIterOptions, fn QuotaStatusPageHandler)

type QuotaStatusEntry

type QuotaStatusEntry struct {
	PercentComplete string `xml:"percent-complete"`
	QuotaErrorMsgs  string `xml:"quota-error-msgs"`
	Reason          string `xml:"reason"`
	QuotaStatus     string `xml:"status"`
	QuotaSubStatus  string `xml:"substatus"`
	Volume          string `xml:"volume"`
	Vserver         string `xml:"vserver"`
}

type QuotaStatusEntryQuery

type QuotaStatusEntryQuery struct {
	QuotaStatusEntry *QuotaStatusEntry `xml:"quota-status-attributes,omitempty"`
}

type QuotaStatusIterOptions

type QuotaStatusIterOptions struct {
	DesiredAttributes *QuotaStatusEntryQuery `xml:"desired-attributes,omitempty"`
	MaxRecords        int                    `xml:"max-records,omitempty"`
	Query             *QuotaStatusEntryQuery `xml:"query,omitempty"`
	Tag               string                 `xml:"tag,omitempty"`
}

type QuotaStatusIterResponse

type QuotaStatusIterResponse struct {
	XMLName xml.Name `xml:"netapp"`
	Results struct {
		ResultBase
		AttributesList struct {
			QuotaStatusAttributes []QuotaStatusEntry `xml:"quota-status-attributes"`
		} `xml:"attributes-list"`
		NextTag    string `xml:"next-tag"`
		NumRecords int    `xml:"num-records"`
	} `xml:"results"`
}

type QuotaStatusPageHandler

type QuotaStatusPageHandler func(QuotaStatusPagesResponse) (shouldContinue bool)

type QuotaStatusPagesResponse

type QuotaStatusPagesResponse struct {
	Response    *QuotaStatusIterResponse
	Error       error
	RawResponse *http.Response
}

type QuotaStatusResponse

type QuotaStatusResponse struct {
	XMLName xml.Name `xml:"netapp"`
	Results struct {
		ResultBase
		QuotaStatus    string `xml:"status"`
		QuotaSubStatus string `xml:"substatus"`
		ResultJobid    string `xml:"result-jobid"`
		ResultStatus   string `xml:"result-status"`
	} `xml:"results"`
}

type Result

type Result interface {
	Passed() bool
	Result() *SingleResultBase
}

type ResultBase

type ResultBase struct {
	Status     string `xml:"status,attr"`
	Reason     string `xml:"reason,attr"`
	NumRecords int    `xml:"num-records"`
	ErrorNo    int    `xml:"errno,attr"`
}

func (*ResultBase) Passed

func (r *ResultBase) Passed() bool

func (*ResultBase) Result

func (r *ResultBase) Result() *SingleResultBase

type SingleResultBase

type SingleResultBase struct {
	Status  string `xml:"status,attr"`
	Reason  string `xml:"reason,attr"`
	ErrorNo int    `xml:"errno,attr"`
}

func (*SingleResultBase) Passed

func (r *SingleResultBase) Passed() bool

func (*SingleResultBase) Result

func (r *SingleResultBase) Result() *SingleResultBase

type SingleResultResponse

type SingleResultResponse struct {
	XMLName xml.Name `xml:"netapp"`
	Results struct {
		SingleResultBase
	} `xml:"results"`
}

SingleResultResponse is used any time only pass/error is communted back to the client from the server

type Snapmirror

type Snapmirror struct {
	Base
	Params struct {
		XMLName           xml.Name
		DesiredAttributes *SnapmirrorInfo `xml:"desired-attributes>snapmirror-info,omitempty"`
		*SnapmirrorInfo
	}
}

Snapmirror is Snapmirror API struct

func (Snapmirror) AbortBy

func (s Snapmirror) AbortBy(query *SnapmirrorInfo, continueOnFailure bool) (*SnapmirrorIterResponse, *http.Response, error)

func (Snapmirror) Create

func (s Snapmirror) Create(vServerName string, attributes *SnapmirrorInfo) (*SingleResultResponse, *http.Response, error)

Create creates a snapmirror on a vserver with attributes provided. Note, not all attributes are supported, refer to docs or api errors to diagnose

func (Snapmirror) DestroyBy

func (s Snapmirror) DestroyBy(query *SnapmirrorInfo, continueOnFailure bool) (*SnapmirrorIterResponse, *http.Response, error)

func (Snapmirror) Get

func (s Snapmirror) Get(vServerName string, sourcePath string, destinationPath string, attributes *SnapmirrorInfo) (*SnapmirrorResponse, *http.Response, error)

Get returns data related to a snapmirror

func (Snapmirror) InitializeLSSet

func (s Snapmirror) InitializeLSSet(vServerName string, sourcePath string) (*SnapmirrorAsyncResponse, *http.Response, error)

InitializeLSSet starts a Load Sharing set via an async call

func (Snapmirror) UpdateLSSet

func (s Snapmirror) UpdateLSSet(vServerName string, sourcePath string) (*SnapmirrorAsyncResponse, *http.Response, error)

UpdateLSSet starts a Load Sharing set via an async call

type SnapmirrorAsyncResponse

type SnapmirrorAsyncResponse struct {
	XMLName xml.Name `xml:"netapp"`
	Results struct {
		AsyncResultBase
	} `xml:"results"`
}

type SnapmirrorInfo

type SnapmirrorInfo struct {
	BreakFailedCount                    int      `xml:"break-failed-count,omitempty"`
	BreakSuccessCount                   int      `xml:"break-successful-count,omitempty"`
	CGItemMappings                      []string `xml:"cg-item-mappings,omitempty"`
	CurrentMaxTransferRate              int      `xml:"current-max-transfer-rate,omitempty"`
	CurrentOperationID                  string   `xml:"current-operation-id,omitempty"`
	CurrentTransferError                string   `xml:"current-transfer-error,omitempty"`
	CurrentTransferPriority             string   `xml:"current-transfer-priority,omitempty"`
	CurrentTransferType                 string   `xml:"current-transfer-type,omitempty"`
	DestinationCluster                  string   `xml:"destination-cluster,omitempty"`
	DestinationLocation                 string   `xml:"destination-location,omitempty"`
	DestinationVolume                   string   `xml:"destination-volume,omitempty"`
	DestinationVolumeNode               string   `xml:"destination-volume-node,omitempty"`
	DestinationVServer                  string   `xml:"destination-vserver,omitempty"`
	ExportedSnapshot                    string   `xml:"exported-snapshot,omitempty"`
	ExportedSnapshotTimestamp           int      `xml:"exported-snapshot-timestamp,omitempty"`
	RestoreFileCount                    int      `xml:"file-restore-file-count,omitempty"`
	RestoreFileList                     []string `xml:"file-restore-file-list,omitempty"`
	IdentitityPreserve                  bool     `xml:"identity-preserve,omitempty"`
	IsConstituent                       bool     `xml:"is-constituent,omitempty"`
	IsHealthy                           bool     `xml:"is-healthy,omitempty"`
	LagTime                             int      `xml:"lag-time,omitempty"`
	LastTransferDuration                int      `xml:"last-transfer-duration,omitempty"`
	LastTransferEndTimestamp            int      `xml:"last-transfer-end-timestamp,omitempty"`
	LastTransferError                   string   `xml:"last-transfer-error,omitempty"`
	LastTransferErrorCodes              []int    `xml:"last-transfer-error-codes,omitempty"`
	LastTransferFrom                    string   `xml:"last-transfer-from,omitempty"`
	LastTransferNetworkCompressionRatio string   `xml:"last-transfer-network-compression-ratio,omitempty"`
	LastTransferSize                    int      `xml:"last-transfer-size,omitempty"`
	LastTransferType                    string   `xml:"last-transfer-type,omitempty"`
	MaxTransferRate                     int      `xml:"max-transfer-rate,omitempty"`
	MirrorState                         string   `xml:"mirror-state,omitempty"`
	NetworkCompressionRatio             string   `xml:"network-compression-ratio,omitempty"`
	NewestSnapshot                      string   `xml:"newest-snapshot,omitempty"`
	NewestSnapshotTimestamp             int      `xml:"newest-snapshot-timestamp,omitempty"`
	Policy                              string   `xml:"policy,omitempty"`
	PolicyType                          string   `xml:"policy-type,omitempty"`
	ProgressLastUpdated                 int      `xml:"progress-last-updated,omitempty"`
	PseudoCommonSnapFailedCount         int      `xml:"pseudo-common-snap-failed-count,omitempty"`
	PseudoCommonSnapSuccessCount        int      `xml:"pseudo-common-snap-success-count,omitempty"`
	RelationshipControlPlane            string   `xml:"relationship-control-plane,omitempty"`
	RelationshipGroupType               string   `xml:"relationship-group-type,omitempty"`
	RelationshipID                      string   `xml:"relationship-id,omitempty"`
	RelationshipProgress                int      `xml:"relationship-progress,omitempty"`
	RelationshipStatus                  string   `xml:"relationship-status,omitempty"`
	RelationshipType                    string   `xml:"relationship-type,omitempty"`
	ResyncAvgTimeSyncCg                 int      `xml:"resync-avg-time-sync-cg,omitempty"`
	ResyncFailedCount                   int      `xml:"resync-failed-count,omitempty"`
	ResyncSuccessCount                  int      `xml:"resync-successful-count,omitempty"`
	Schedule                            string   `xml:"schedule,omitempty"`
	SnapshotCheckpoint                  int      `xml:"snapshot-checkpoint,omitempty"`
	SnapshotProgress                    int      `xml:"snapshot-progress,omitempty"`
	SourceCluster                       string   `xml:"source-cluster,omitempty"`
	SourceLocation                      string   `xml:"source-location,omitempty"`
	SourceVolume                        string   `xml:"source-volume,omitempty"`
	SourceVolumeNode                    string   `xml:"source-volume-node,omitempty"`
	SourceVServer                       string   `xml:"source-vserver,omitempty"`
	TotalTransferBytes                  int      `xml:"total-transfer-bytes,omitempty"`
	TotalTransferTime                   int      `xml:"total-transfer-time,omitempty"`
	TransferSnapshot                    string   `xml:"transfer-snapshot,omitempty"`
	Tries                               string   `xml:"tries,omitempty"`
	UnhealthyReason                     string   `xml:"unhealthy-reason,omitempty"`
	UpdateFailedCount                   int      `xml:"update-failed-count,omitempty"`
	UpdateSuccessCount                  int      `xml:"update-successful-count,omitempty"`
	VServer                             string   `xml:"vserver,omitempty"`
}

SnapmirrorInfo contains all fields for snapmirror data

type SnapmirrorIterResponse

type SnapmirrorIterResponse struct {
	XMLName xml.Name `xml:"netapp"`
	Results struct {
		NumFailed    int `xml:"num-failed"`
		NumSucceeded int `xml:"num-succeeded"`
		FailureList  []struct {
			ErrorNo int             `xml:"error-code"`
			Reason  string          `xml:"error-message"`
			Info    *SnapmirrorInfo `xml:"snapmirror-key>snapmirror-info"`
		} `xml:"failure-list>snapmirror-destroy-iter-info"`
		SuccessList []struct {
			Info *SnapmirrorInfo `xml:"snapmirror-key>snapmirror-info"`
		} `xml:"success-list>snapmirror-destroy-iter-info"`
	} `xml:"results"`
}

type SnapmirrorResponse

type SnapmirrorResponse struct {
	XMLName xml.Name `xml:"netapp"`
	Results struct {
		SingleResultBase
		Info *SnapmirrorInfo `xml:"attributes>snapmirror-info"`
	} `xml:"results"`
}

SnapmirrorResponse returns results for snapmirror

type Snapshot

type Snapshot struct {
	Base
	Params struct {
		XMLName xml.Name
		*SnapshotOptions
	}
}

func (*Snapshot) List

func (v *Snapshot) List(options *SnapshotOptions) (*SnapshotListResponse, *http.Response, error)

func (*Snapshot) ListPages

func (v *Snapshot) ListPages(options *SnapshotOptions, fn SnapshotPageHandler)

type SnapshotInfo

type SnapshotInfo struct {
	AccessTime                        int    `xml:"access-time"`
	Busy                              bool   `xml:"busy"`
	ContainsLunClones                 bool   `xml:"contains-lun-clones"`
	CumulativePercentageOfTotalBlocks int    `xml:"cumulative-percentage-of-total-blocks"`
	CumulativePercentageOfUsedBlocks  int    `xml:"cumulative-percentage-of-used-blocks"`
	CumulativeTotal                   int    `xml:"cumulative-total"`
	Dependency                        string `xml:"dependency"`
	Is7ModeSnapshot                   bool   `xml:"is-7-mode-snapshot"`
	Name                              string `xml:"name"`
	PercentageOfTotalBlocks           int    `xml:"percentage-of-total-blocks"`
	PercentageOfUsedBlocks            int    `xml:"percentage-of-used-blocks"`
	SnapmirrorLabel                   string `xml:"snapmirror-label"`
	SnapshotInstanceUuid              string `xml:"snapshot-instance-uuid"`
	SnapshotVersionUuid               string `xml:"snapshot-version-uuid"`
	State                             string `xml:"state"`
	Total                             int    `xml:"total"`
	Volume                            string `xml:"volume"`
	VolumeProvenanceUuid              string `xml:"volume-provenance-uuid"`
	Vserver                           string `xml:"vserver"`
}

type SnapshotListPagesResponse

type SnapshotListPagesResponse struct {
	Response    *SnapshotListResponse
	Error       error
	RawResponse *http.Response
}

type SnapshotListResponse

type SnapshotListResponse struct {
	XMLName xml.Name `xml:"netapp"`
	Results struct {
		ResultBase
		AttributesList struct {
			SnapshotAttributes []SnapshotInfo `xml:"snapshot-info"`
		} `xml:"attributes-list"`
		NextTag    string `xml:"next-tag"`
		NumRecords int    `xml:"num-records"`
	} `xml:"results"`
}

type SnapshotOptions

type SnapshotOptions struct {
	DesiredAttributes *SnapshotQuery `xml:"desired-attributes,omitempty"`
	MaxRecords        int            `xml:"max-records,omitempty"`
	Query             *SnapshotQuery `xml:"query,omitempty"`
	Tag               string         `xml:"tag,omitempty"`
}

type SnapshotPageHandler

type SnapshotPageHandler func(SnapshotListPagesResponse) (shouldContinue bool)

type SnapshotQuery

type SnapshotQuery struct {
	SnapshotInfo *SnapshotInfo `xml:"snapshot-info,omitempty"`
}

type StorageDisk

type StorageDisk struct {
	Base
	Params struct {
		XMLName xml.Name
		*StorageDiskOptions
	}
}

func (*StorageDisk) StorageDiskGetAll

func (s *StorageDisk) StorageDiskGetAll(options *StorageDiskOptions, fn StorageDiskGetAllPageHandler)

func (*StorageDisk) StorageDiskGetIter

func (s *StorageDisk) StorageDiskGetIter(options *StorageDiskOptions) (*StorageDiskGetIterResponse, *http.Response, error)

type StorageDiskGetAllPageHandler

type StorageDiskGetAllPageHandler func(StorageDiskInfoPageResponse) (shouldContinue bool)

type StorageDiskGetIterResponse

type StorageDiskGetIterResponse struct {
	XMLName xml.Name `xml:"netapp"`
	Results struct {
		ResultBase
		AttributesList struct {
			StorageDiskInfo []StorageDiskInfo `xml:"storage-disk-info"`
		} `xml:"attributes-list"`
		NextTag    string `xml:"next-tag"`
		NumRecords int    `xml:"num-records"`
	} `xml:"results"`
}

type StorageDiskInfo

type StorageDiskInfo struct {
	DiskInventoryInfo *DiskInventoryInfo `xml:"disk-inventory-info,omitempty"`
	DiskName          string             `xml:"disk-name,omitempty"`
	DiskOwnershipInfo *DiskOwnershipInfo `xml:"disk-ownership-info,omitempty"`
}

type StorageDiskInfoPageResponse

type StorageDiskInfoPageResponse struct {
	Response    *StorageDiskGetIterResponse
	Error       error
	RawResponse *http.Response
}

type StorageDiskOptions

type StorageDiskOptions struct {
	DesiredAttributes *StorageDiskInfo `xml:"desired-attributes>storage-disk-info,omitempty"`
	Query             *StorageDiskInfo `xml:"query>storage-disk-info,omitempty"`
	MaxRecords        int              `xml:"max-records,omitempty"`
	Tag               string           `xml:"tag,omitempty"`
}

type StorageFailoverInfo

type StorageFailoverInfo struct {
	InterconnectRelatedInfo *InterconnectRelatedInfo `xml:"sfo-interconnect-info>interconnect-related-info"`
	NodeRelatedInfo         *NodeRelatedInfo         `xml:"sfo-node-info>node-related-info"`
	TakeoverRelatedInfo     *TakeoverRelatedInfo     `xml:"sfo-takeover-info>takeover-related-info"`
	GivebackRelatedInfo     *GivebackRelatedInfo     `xml:"sfo-giveback-info>giveback-related-info"`
}

type StorageFailoverInfoPageHandler

type StorageFailoverInfoPageHandler func(ClusterFailoverInfoPagesResponse) (shouldContinue bool)

type StorageFailoverInfoQuery

type StorageFailoverInfoQuery struct {
	StorageFailoverInfo *StorageFailoverInfo `xml:"storage-failover-info,omitempty"`
}

type System

type System struct {
	Base
	Params struct {
		XMLName xml.Name
		*NodeDetailOptions
	}
}

func (*System) List

func (s *System) List(options *NodeDetailOptions) (*NodeDetailsResponse, *http.Response, error)

func (*System) ListPages

func (s *System) ListPages(options *NodeDetailOptions, fn NodeDetailsPageHandler)

type TakeoverRelatedInfo

type TakeoverRelatedInfo struct {
	TakeoverByPartnerPossible bool   `xml:"takeover-by-partner-possible"`
	TakeoverEnabled           bool   `xml:"takeover-enabled"`
	TakeoverFailureReason     string `xml:"takeover-failure-reason"`
	TakeoverModule            string `xml:"takeover-module"`
	TakeoverOfPartnerPossible bool   `xml:"takeover-of-partner-possible"`
	TakeoverReason            string `xml:"takeover-reason"`
	TakeoverState             string `xml:"takeover-state"`
	TimeSinceTakeover         int    `xml:"time-since-takeover"`
	TimeUntilTakeover         int    `xml:"time-until-takeover"`
}

type VServer

type VServer struct {
	Base
	Params struct {
		XMLName     xml.Name
		VServerInfo `xml:",innerxml"`
		VServerOptions
	}
}

func (VServer) AddInitiator

func (v VServer) AddInitiator(vServerName string, iGroupName string, initiator string) (*VServerIgroupsResponse, *http.Response, error)

AddInitiator add an initiator to an igroup

func (VServer) Create

func (v VServer) Create(options *VServerInfo) (*VServerAsyncResponse, *http.Response, error)

Create creates a new VServer

func (VServer) CreateExportRule

func (v VServer) CreateExportRule(vServerName string, options *VServerExportRuleInfo) (*VServerExportsResponse, *http.Response, error)

CreateExportRule creates a new export rule for a given vserver

func (VServer) CreateNfsService

func (v VServer) CreateNfsService(vServerName string, options *VServerNfsCreateOptions) (*SingleResultResponse, *http.Response, error)

CreateNfsService configures and enables nfs service on a vserver

func (VServer) Delete

func (v VServer) Delete(name string) (*VServerListResponse, *http.Response, error)

func (VServer) DeleteExportRule

func (v VServer) DeleteExportRule(vServerName string, policyName string, ruleIndex int) (*VServerExportsResponse, *http.Response, error)

DeleteExportRule removes an export rule for a given vserver, policy and rule index

func (VServer) Get

func (v VServer) Get(name string, options *VServerOptions) (*VServerResponse, *http.Response, error)

func (VServer) List

func (v VServer) List(options *VServerOptions) (*VServerListResponse, *http.Response, error)

func (VServer) ListExportRules

func (v VServer) ListExportRules(vServerName string) (*ExportRuleListResponse, *http.Response, error)

ListExportRules lists all export rules on a vserver

func (VServer) Modify

func (v VServer) Modify(name string, options *VServerInfo) (*SingleResultResponse, *http.Response, error)

func (VServer) RemoveInitiator

func (v VServer) RemoveInitiator(vServerName string, iGroupName string, initiator string, force bool) (*VServerIgroupsResponse, *http.Response, error)

RemoveInitiator add an initiator to an igroup

type VServerAsyncResponse

type VServerAsyncResponse struct {
	XMLName xml.Name `xml:"netapp"`
	Results struct {
		AsyncResultBase
		VServerInfo VServerInfo `xml:"result>vserver-info"`
	} `xml:"results"`
}

VServerAsyncResponse returns job-based responses

type VServerExportRuleInfo

type VServerExportRuleInfo struct {
	AnonymousUserID           int       `xml:"anonymous-user-id,omitempty"`
	ClientMatch               string    `xml:"client-match,omitempty"`
	ExportChownMode           string    `xml:"export-chown-mode,omitempty"`
	ExportNTFSUnixSecurityOps string    `xml:"export-ntfs-unix-security-ops,omitempty"`
	AllowCreateDevices        bool      `xml:"is-allow-dev-is-enabled,omitempty"`
	AllowSetUID               bool      `xml:"is-allow-set-uid-enabled,omitempty"`
	PolicyName                string    `xml:"policy-name,omitempty"`
	Protocol                  *[]string `xml:"protocol>access-protocol,omitempty"`
	ReadOnlyRule              *[]string `xml:"ro-rule>security-flavor,omitempty"`
	RuleIndex                 int       `xml:"rule-index,omitempty"`
	ReadWriteRule             *[]string `xml:"rw-rule>security-flavor,omitempty"`
	SuperUserSecurity         *[]string `xml:"super-user-security>security-flavor,omitempty"`
}

VServerExportRuleInfo sets all different options for Export Rules

type VServerExportsResponse

type VServerExportsResponse struct {
	XMLName xml.Name `xml:"netapp"`
	Results struct {
		SingleResultBase
	} `xml:"results"`
}

VServerExportsResponse creates correct response obj

type VServerIgroupInfo

type VServerIgroupInfo struct {
	PortsetName        string `xml:"initiator-group-portset-name,omitempty"`
	InitiatorGroupName string `xml:"initiator-group-name,omitempty"`
	InitiatorGroupUUID string `xml:"initiator-group-uuid,omitempty"`
	InitiatorName      string `xml:"initiator,omitempty"`
	Force              bool   `xml:"force,omitempty"`
}

VServerIgroupInfo sets all different options for the igroup

type VServerIgroupsResponse

type VServerIgroupsResponse struct {
	XMLName xml.Name `xml:"netapp"`
	Results struct {
		SingleResultBase
	} `xml:"results"`
}

VServerIgroupsResponse creates correct response obj

type VServerInfo

type VServerInfo struct {
	AntivirusOnAccessPolicy    string    `xml:"antivirus-on-access-policy,omitempty"`
	AggregateList              *[]string `xml:"aggr-list>aggr-name"`
	Comment                    string    `xml:"comment,omitempty"`
	Ipspace                    string    `xml:"ipspace,omitempty"`
	IsRepositoryVserver        string    `xml:"is-repository-vserver,omitempty"`
	SnapshotPolicy             string    `xml:"snapshot-policy,omitempty"`
	UUID                       string    `xml:"uuid,omitempty"`
	VserverName                string    `xml:"vserver-name,omitempty"`
	VserverType                string    `xml:"vserver-type,omitempty"`
	AllowedProtocols           *[]string `xml:"allowed-protocols>protocol,omitempty"`
	DisallowedProtocols        *[]string `xml:"disallowed-protocols>protocol,omitempty"`
	IsConfigLockedForChanges   bool      `xml:"is-config-locked-for-changes,omitempty"`
	Language                   string    `xml:"language,omitempty"`
	MaxVolumes                 string    `xml:"max-volumes,omitempty"`
	NameMappingSwitch          *[]string `xml:"name-mapping-switch>nmswitch,omitempty"`
	NameServerSwitch           *[]string `xml:"name-server-switch>nsswitch,omitempty"`
	OperationalState           string    `xml:"operational-state,omitempty"`
	QuotaPolicy                string    `xml:"quota-policy,omitempty"`
	RootVolume                 string    `xml:"root-volume,omitempty"`
	RootVolumeAggregate        string    `xml:"root-volume-aggregate,omitempty"`
	RootVolumeSecurityStyle    string    `xml:"root-volume-security-style,omitempty"`
	State                      string    `xml:"state,omitempty"`
	VolumeDeleteRetentionHours int       `xml:"volume-delete-retention-hours,omitempty"`
	VserverSubtype             string    `xml:"vserver-subtype,omitempty"`
}

type VServerListResponse

type VServerListResponse struct {
	XMLName xml.Name `xml:"netapp"`
	Results struct {
		ResultBase
		AttributesList struct {
			VserverInfo []VServerInfo `xml:"vserver-info"`
		} `xml:"attributes-list"`
	} `xml:"results"`
}

type VServerNfsCreateOptions

type VServerNfsCreateOptions struct {
	NfsAccessEnabled bool `xml:"is-nfs-access-enabled"`
	NfsV3Enabled     bool `xml:"is-nfsv3-enabled"`
	NfsV4Enabled     bool `xml:"is-nfsv40-enabled"`
	VStorageEnabled  bool `xml:"is-vstorage-enabled"`
}

type VServerOptions

type VServerOptions struct {
	DesiredAttributes *VServerQuery `xml:"desired-attributes,omitempty"`
	MaxRecords        int           `xml:"max-records,omitempty"`
	Query             *VServerQuery `xml:"query,omitempty"`
	Tag               string        `xml:"tag,omitempty"`
}

type VServerQuery

type VServerQuery struct {
	VServerInfo *VServerInfo `xml:"vserver-info,omitempty"`
}

type VServerResponse

type VServerResponse struct {
	XMLName xml.Name `xml:"netapp"`
	Results struct {
		SingleResultBase
		VServerInfo VServerInfo `xml:"attributes>vserver-info"`
	} `xml:"results"`
}

type Volume

type Volume struct {
	Base
	Params struct {
		XMLName xml.Name
		*VolumeOptions
	}
}

func (Volume) List

func (v Volume) List(options *VolumeOptions) (*VolumeListResponse, *http.Response, error)

func (*Volume) ListPages

func (v *Volume) ListPages(options *VolumeOptions, fn VolumePageHandler)

func (Volume) Modify

func (v Volume) Modify(options *VolumeOptions) (*VolumeModifyResponce, *http.Response, error)

Modify changes some volume properties, note: it will silently ignore things it cannot change

type VolumeAntivirusAttributes

type VolumeAntivirusAttributes struct {
	OnAccessPolicy string `xml:"on-access-policy"`
}

type VolumeAutobalanceAttributes

type VolumeAutobalanceAttributes struct {
	IsAutobalanceEligible string `xml:"is-autobalance-eligible"`
}

type VolumeAutosizeAttributes

type VolumeAutosizeAttributes struct {
	GrowThresholdPercent   string `xml:"grow-threshold-percent"`
	IsEnabled              string `xml:"is-enabled"`
	MaximumSize            string `xml:"maximum-size"`
	MinimumSize            string `xml:"minimum-size"`
	Mode                   string `xml:"mode"`
	ShrinkThresholdPercent string `xml:"shrink-threshold-percent"`
}

type VolumeCreateOptions

type VolumeCreateOptions struct {
	AntivirusOnAccessPolicy    string `xml:"antivirus-on-access-policy,omitempty"`
	CacheRetentionPriority     string `xml:"cache-retention-priority,omitempty"`
	CachingPolicy              string `xml:"caching-policy,omitempty"`
	ConstituentRole            string `xml:"constituent-role,omitempty"`
	ContainingAggregateName    string `xml:"containing-aggr-name,omitempty"`
	EfficiencyPolicy           string `xml:"efficiency-policy,omitempty"`
	Encrypt                    bool   `xml:"encrypt,omitempty"`
	ExcludedFromAutobalance    bool   `xml:"excluded-from-autobalance,omitempty"`
	ExportPolicy               string `xml:"export-policy,omitempty"`
	ExtentSize                 string `xml:"extent-size,omitempty"`
	FlexcachePolicy            string `xml:"flexcache-cache-policy,omitempty"`
	FlexcacheFillPolicy        string `xml:"flexcache-fill-policy,omitempty"`
	FlexcacheOriginVolumeName  string `xml:"flexcache-origin-volume-name,omitempty"`
	GroupID                    int    `xml:"group-id,omitempty"`
	IsJunctionActive           bool   `xml:"is-junction-active,omitempty"`
	IsNvfailEnabled            string `xml:"is-nvfail-enabled,omitempty"`
	IsVserverRoot              bool   `xml:"is-vserver-root,omitempty"`
	JunctionPath               string `xml:"junction-path,omitempty"`
	LanguageCode               string `xml:"language-code,omitempty"`
	MaxDirSize                 int    `xml:"max-dir-size,omitempty"`
	MaxWriteAllocBlocks        int    `xml:"max-write-alloc-blocks,omitempty"`
	PercentageSnapshotReserve  int    `xml:"percentage-snapshot-reserve,omitempty"`
	QosAdaptivePolicyGroupName string `xml:"qos-adaptive-policy-group-name,omitempty"`
	QosPolicyGroupName         string `xml:"qos-policy-group-name,omitempty"`
	Size                       string `xml:"size,omitempty"`
	SnapshotPolicy             string `xml:"snapshot-policy,omitempty"`
	SpaceReserve               string `xml:"space-reserve,omitempty"`
	SpaceSlo                   string `xml:"space-slo,omitempty"`
	StorageService             string `xml:"storage-service,omitempty"`
	TieringPolicy              string `xml:"tiering-policy,omitempty"`
	UnixPermissions            string `xml:"unix-permissions,omitempty"`
	UserID                     int    `xml:"user-id,omitempty"`
	VMAlignSector              int    `xml:"vm-align-sector,omitempty"`
	VMAlignSuffix              string `xml:"vm-align-suffix,omitempty"`
	Volume                     string `xml:"volume,omitempty"`
	VolumeComment              string `xml:"volume-comment,omitempty"`
	VolumeSecurityStyle        string `xml:"volume-security-style,omitempty"`
	VolumeState                string `xml:"volume-state,omitempty"`
	VolumeType                 string `xml:"volume-type,omitempty"`
	VserverDrProtection        string `xml:"vserver-dr-protection,omitempty"`
}

VolumeCreateOptions struct is used for volume creation

type VolumeDirectoryAttributes

type VolumeDirectoryAttributes struct {
	I2PEnabled string `xml:"i2p-enabled"`
	MaxDirSize string `xml:"max-dir-size"`
	RootDirGen string `xml:"root-dir-gen"`
}

type VolumeExportAttributes

type VolumeExportAttributes struct {
	Policy string `xml:"policy"`
}

type VolumeHybridCacheAttributes

type VolumeHybridCacheAttributes struct {
	CacheRetentionPriority string `xml:"cache-retention-priority"`
	CachingPolicy          string `xml:"caching-policy"`
	Eligibility            string `xml:"eligibility"`
}

type VolumeIDAttributes

type VolumeIDAttributes struct {
	AggrList                []string `xml:"aggr-list>aggr-name,omitempty"`
	Comment                 string   `xml:"comment,omitempty"`
	ContainingAggregateName string   `xml:"containing-aggregate-name,omitempty"`
	ContainingAggregateUUID string   `xml:"containing-aggregate-uuid,omitempty"`
	CreationTime            string   `xml:"creation-time,omitempty"`
	Dsid                    string   `xml:"dsid,omitempty"`
	Fsid                    string   `xml:"fsid,omitempty"`
	InstanceUUID            string   `xml:"instance-uuid,omitempty"`
	JunctionParentName      string   `xml:"junction-parent-name,omitempty"`
	JunctionPath            string   `xml:"junction-path,omitempty"`
	Msid                    string   `xml:"msid,omitempty"`
	Name                    string   `xml:"name,omitempty"`
	NameOrdinal             string   `xml:"name-ordinal,omitempty"`
	Node                    string   `xml:"node,omitempty"`
	Nodes                   []string `xml:"nodes>node-name,omitempty"`
	OwningVserverName       string   `xml:"owning-vserver-name,omitempty"`
	OwningVserverUUID       string   `xml:"owning-vserver-uuid,omitempty"`
	ProvenanceUUID          string   `xml:"provenance-uuid,omitempty"`
	Style                   string   `xml:"style,omitempty"`
	StyleExtended           string   `xml:"style-extended,omitempty"`
	Type                    string   `xml:"type,omitempty"`
	UUID                    string   `xml:"uuid,omitempty"`
}

type VolumeInfo

type VolumeInfo struct {
	Encrypt                            string                              `xml:"encrypt,omitempty"`
	KeyID                              string                              `xml:"key-id,omitempty"`
	VolumeAntivirusAttributes          *VolumeAntivirusAttributes          `xml:"volume-antivirus-attributes,omitempty"`
	VolumeAutobalanceAttributes        *VolumeAutobalanceAttributes        `xml:"volume-autobalance-attributes,omitempty"`
	VolumeAutosizeAttributes           *VolumeAutosizeAttributes           `xml:"volume-autosize-attributes"`
	VolumeDirectoryAttributes          *VolumeDirectoryAttributes          `xml:"volume-directory-attributes"`
	VolumeExportAttributes             *VolumeExportAttributes             `xml:"volume-export-attributes,omitempty"`
	VolumeHybridCacheAttributes        *VolumeHybridCacheAttributes        `xml:"volume-hybrid-cache-attributes,omitempty"`
	VolumeIDAttributes                 *VolumeIDAttributes                 `xml:"volume-id-attributes,omitempty"`
	VolumeInodeAttributes              *VolumeInodeAttributes              `xml:"volume-inode-attributes,omitempty"`
	VolumeLanguageAttributes           *VolumeLanguageAttributes           `xml:"volume-language-attributes,omitempty"`
	VolumeMirrorAttributes             *VolumeMirrorAttributes             `xml:"volume-mirror-attributes,omitempty"`
	VolumePerformanceAttributes        *VolumePerformanceAttributes        `xml:"volume-performance-attributes,omitempty"`
	VolumeQosAttributes                *VolumeQosAttributes                `xml:"volume-qos-attributes,omitempty"`
	VolumeSecurityAttributes           *VolumeSecurityAttributes           `xml:"volume-security-attributes,omitempty"`
	VolumeSisAttributes                *VolumeSisAttributes                `xml:"volume-sis-attributes,omitempty"`
	VolumeSnaplockAttributes           *VolumeSnaplockAttributes           `xml:"volume-snaplock-attributes,omitempty"`
	VolumeSnapshotAttributes           *VolumeSnapshotAttributes           `xml:"volume-snapshot-attributes,omitempty"`
	VolumeSnapshotAutodeleteAttributes *VolumeSnapshotAutodeleteAttributes `xml:"volume-snapshot-autodelete-attributes,omitempty"`
	VolumeSpaceAttributes              *VolumeSpaceAttributes              `xml:"volume-space-attributes,omitempty"`
	VolumeStateAttributes              *VolumeStateAttributes              `xml:"volume-state-attributes,omitempty"`
	VolumeTransitionAttributes         *VolumeTransitionAttributes         `xml:"volume-transition-attributes,omitempty"`
}

type VolumeInodeAttributes

type VolumeInodeAttributes struct {
	BlockType                string `xml:"block-type"`
	FilesPrivateUsed         string `xml:"files-private-used"`
	FilesTotal               string `xml:"files-total"`
	FilesUsed                string `xml:"files-used"`
	InodefilePrivateCapacity string `xml:"inodefile-private-capacity"`
	InodefilePublicCapacity  string `xml:"inodefile-public-capacity"`
	InofileVersion           string `xml:"inofile-version"`
}

type VolumeLanguageAttributes

type VolumeLanguageAttributes struct {
	IsConvertUcodeEnabled string `xml:"is-convert-ucode-enabled"`
	IsCreateUcodeEnabled  string `xml:"is-create-ucode-enabled"`
	Language              string `xml:"language"`
	LanguageCode          string `xml:"language-code"`
	NfsCharacterSet       string `xml:"nfs-character-set"`
	OemCharacterSet       string `xml:"oem-character-set"`
}

type VolumeListPagesResponse

type VolumeListPagesResponse struct {
	Response    *VolumeListResponse
	Error       error
	RawResponse *http.Response
}

type VolumeListResponse

type VolumeListResponse struct {
	XMLName xml.Name `xml:"netapp"`
	Results struct {
		ResultBase
		AttributesList []VolumeInfo `xml:"attributes-list>volume-attributes"`
		NextTag        string       `xml:"next-tag"`
		NumRecords     int          `xml:"num-records"`
	} `xml:"results"`
}

type VolumeMirrorAttributes

type VolumeMirrorAttributes struct {
	IsDataProtectionMirror   string `xml:"is-data-protection-mirror"`
	IsLoadSharingMirror      string `xml:"is-load-sharing-mirror"`
	IsMoveMirror             string `xml:"is-move-mirror"`
	IsReplicaVolume          string `xml:"is-replica-volume"`
	MirrorTransferInProgress string `xml:"mirror-transfer-in-progress"`
	RedirectSnapshotID       string `xml:"redirect-snapshot-id"`
}

type VolumeModifyInfo

type VolumeModifyInfo struct {
	ErrorCode    int         `xml:"error-code,omitempty"`
	ErrorMessage string      `xml:"error-message,omitempty"`
	VolumeKey    *VolumeInfo `xml:"volume-key,omitempty"`
}

type VolumeModifyOptions

type VolumeModifyOptions struct {
	*VolumeOptions
	ContinueOnFailure bool `xml:"continue-on-failure,omitempty"`
	MaxFailureCount   int  `xml:"max-failure-count,omitempty"`
	ReturnFailureList bool `xml:"return-failure-list,omitempty"`
	ReturnSuccessList bool `xml:"return-success-list,omitempty"`
}

type VolumeModifyResponce

type VolumeModifyResponce struct {
	XMLName xml.Name `xml:"netapp"`
	Results struct {
		SingleResultBase
		FailureList     *[]VolumeModifyInfo `xml:"failure-list>volume-modify-iter-info"`
		SuccessList     *[]VolumeModifyInfo `xml:"success-list>volume-modify-iter-info"`
		NextTag         string              `xml:"next-tag"`
		NumberSucceeded int                 `xml:"num-succeeded"`
		NumberFailed    int                 `xml:"num-failed"`
	} `xml:"results"`
}

type VolumeOperation

type VolumeOperation struct {
	Base
	Params struct {
		XMLName    xml.Name
		VolumeName *volumeName
		VolumeCreateOptions
	}
}

VolumeOperation is the base struct for volume operations

func (VolumeOperation) Create

func (v VolumeOperation) Create(vserverName string, options *VolumeCreateOptions) (*SingleResultResponse, *http.Response, error)

Create a new volume

func (VolumeOperation) Operation

func (v VolumeOperation) Operation(vserverName string, volName string, operation string) (*SingleResultResponse, *http.Response, error)

Operation runs several operations (from consts defined above with VolumeOperation* name)

type VolumeOptions

type VolumeOptions struct {
	DesiredAttributes *VolumeQuery `xml:"desired-attributes,omitempty"`
	Attributes        *VolumeQuery `xml:"attributes,omitempty"`
	MaxRecords        int          `xml:"max-records,omitempty"`
	Query             *VolumeQuery `xml:"query,omitempty"`
	Tag               string       `xml:"tag,omitempty"`
}

type VolumePageHandler

type VolumePageHandler func(VolumeListPagesResponse) (shouldContinue bool)

type VolumePerformanceAttributes

type VolumePerformanceAttributes struct {
	ExtentEnabled        string `xml:"extent-enabled"`
	FcDelegsEnabled      string `xml:"fc-delegs-enabled"`
	IsAtimeUpdateEnabled string `xml:"is-atime-update-enabled"`
	MaxWriteAllocBlocks  string `xml:"max-write-alloc-blocks"`
	MinimalReadAhead     string `xml:"minimal-read-ahead"`
	ReadRealloc          string `xml:"read-realloc"`
}

type VolumeQosAttributes

type VolumeQosAttributes struct {
	AdaptivePolicyGroupName string `xml:"adaptive-policy-group-name,omitempty"`
	PolicyGroupName         string `xml:"policy-group-name"`
}

VolumeQosAttributes is for tracking QOS-related volume attributes

type VolumeQuery

type VolumeQuery struct {
	VolumeInfo *VolumeInfo `xml:"volume-attributes,omitempty"`
}

type VolumeSecurityAttributes

type VolumeSecurityAttributes struct {
	Style                        string `xml:"style"`
	VolumeSecurityUnixAttributes struct {
		GroupID     string `xml:"group-id"`
		Permissions string `xml:"permissions"`
		UserID      string `xml:"user-id"`
	} `xml:"volume-security-unix-attributes"`
}

type VolumeSisAttributes

type VolumeSisAttributes struct {
	CompressionSpaceSaved             string `xml:"compression-space-saved"`
	DeduplicationSpaceSaved           string `xml:"deduplication-space-saved"`
	DeduplicationSpaceShared          string `xml:"deduplication-space-shared"`
	IsSisLoggingEnabled               string `xml:"is-sis-logging-enabled"`
	IsSisStateEnabled                 string `xml:"is-sis-state-enabled"`
	IsSisVolume                       string `xml:"is-sis-volume"`
	PercentageCompressionSpaceSaved   string `xml:"percentage-compression-space-saved"`
	PercentageDeduplicationSpaceSaved string `xml:"percentage-deduplication-space-saved"`
	PercentageTotalSpaceSaved         string `xml:"percentage-total-space-saved"`
	TotalSpaceSaved                   string `xml:"total-space-saved"`
}

type VolumeSnaplockAttributes

type VolumeSnaplockAttributes struct {
	SnaplockType string `xml:"snaplock-type"`
}

type VolumeSnapshotAttributes

type VolumeSnapshotAttributes struct {
	AutoSnapshotsEnabled           string `xml:"auto-snapshots-enabled,omitempty"`
	SnapdirAccessEnabled           bool   `xml:"snapdir-access-enabled,omitempty"`
	SnapshotCloneDependencyEnabled string `xml:"snapshot-clone-dependency-enabled,omitempty"`
	SnapshotCount                  string `xml:"snapshot-count,omitempty"`
	SnapshotPolicy                 string `xml:"snapshot-policy,omitempty"`
}

type VolumeSnapshotAutodeleteAttributes

type VolumeSnapshotAutodeleteAttributes struct {
	Commitment          string `xml:"commitment"`
	DeferDelete         string `xml:"defer-delete"`
	DeleteOrder         string `xml:"delete-order"`
	DestroyList         string `xml:"destroy-list"`
	IsAutodeleteEnabled string `xml:"is-autodelete-enabled"`
	Prefix              string `xml:"prefix"`
	TargetFreeSpace     string `xml:"target-free-space"`
	Trigger             string `xml:"trigger"`
}

type VolumeSpace

type VolumeSpace struct {
	Base
	Params struct {
		XMLName xml.Name
		*VolumeSpaceOptions
	}
}

func (*VolumeSpace) List

func (v *VolumeSpace) List(options *VolumeSpaceOptions) (*VolumeSpaceListResponse, *http.Response, error)

type VolumeSpaceAttributes

type VolumeSpaceAttributes struct {
	FilesystemSize                  string `xml:"filesystem-size,omitempty"`
	IsFilesysSizeFixed              string `xml:"is-filesys-size-fixed,omitempty"`
	IsSpaceGuaranteeEnabled         string `xml:"is-space-guarantee-enabled,omitempty"`
	IsSpaceSloEnabled               string `xml:"is-space-slo-enabled,omitempty"`
	LogicalUsed                     string `xml:"logical-used,omitempty"`
	LogicalUsedByAfs                string `xml:"logical-used-by-afs,omitempty"`
	LogicalUsedBySnapshot           string `xml:"logical-used-by-snapshot,omitempty"`
	LogicalUsedPercent              string `xml:"logical-used-percent,omitempty"`
	OverwriteReserve                string `xml:"overwrite-reserve,omitempty"`
	OverwriteReserveRequired        string `xml:"overwrite-reserve-required,omitempty"`
	OverwriteReserveUsed            string `xml:"overwrite-reserve-used,omitempty"`
	OverwriteReserveUsedActual      string `xml:"overwrite-reserve-used-actual,omitempty"`
	PercentageFractionalReserve     string `xml:"percentage-fractional-reserve,omitempty"`
	PercentageSizeUsed              string `xml:"percentage-size-used,omitempty"`
	PercentageSnapshotReserve       string `xml:"percentage-snapshot-reserve,omitempty"`
	PercentageSnapshotReserveUsed   string `xml:"percentage-snapshot-reserve-used,omitempty"`
	PhysicalUsed                    string `xml:"physical-used,omitempty"`
	PhysicalUsedPercent             string `xml:"physical-used-percent,omitempty"`
	Size                            int    `xml:"size,omitempty"`
	SizeAvailable                   string `xml:"size-available,omitempty"`
	SizeAvailableForSnapshots       string `xml:"size-available-for-snapshots,omitempty"`
	SizeTotal                       string `xml:"size-total,omitempty"`
	SizeUsed                        string `xml:"size-used,omitempty"`
	SizeUsedBySnapshots             string `xml:"size-used-by-snapshots,omitempty"`
	SnapshotReserveSize             string `xml:"snapshot-reserve-size,omitempty"`
	SpaceFullThresholdPercent       string `xml:"space-full-threshold-percent,omitempty"`
	SpaceGuarantee                  string `xml:"space-guarantee,omitempty"`
	SpaceMgmtOptionTryFirst         string `xml:"space-mgmt-option-try-first,omitempty"`
	SpaceNearlyFullThresholdPercent string `xml:"space-nearly-full-threshold-percent,omitempty"`
	SpaceSlo                        string `xml:"space-slo,omitempty"`
}

type VolumeSpaceInfo

type VolumeSpaceInfo struct {
	FilesystemMetadata         string `xml:"filesystem-metadata"`
	FilesystemMetadataPercent  string `xml:"filesystem-metadata-percent"`
	Inodes                     string `xml:"inodes"`
	InodesPercent              string `xml:"inodes-percent"`
	PerformanceMetadata        string `xml:"performance-metadata"`
	PerformanceMetadataPercent string `xml:"performance-metadata-percent"`
	PhysicalUsed               int    `xml:"physical-used"`
	PhysicalUsedPercent        string `xml:"physical-used-percent"`
	SnapshotReserve            string `xml:"snapshot-reserve"`
	SnapshotReservePercent     string `xml:"snapshot-reserve-percent"`
	TotalUsed                  int    `xml:"total-used"`
	TotalUsedPercent           string `xml:"total-used-percent"`
	UserData                   string `xml:"user-data"`
	UserDataPercent            string `xml:"user-data-percent"`
	Volume                     string `xml:"volume"`
	Vserver                    string `xml:"vserver"`
}

type VolumeSpaceInfoQuery

type VolumeSpaceInfoQuery struct {
	VolumeSpaceInfo *VolumeSpaceInfo `xml:"space-info,omitempty"`
}

type VolumeSpaceListResponse

type VolumeSpaceListResponse struct {
	XMLName xml.Name `xml:"netapp"`
	Results struct {
		ResultBase
		AttributesList struct {
			SpaceInfo VolumeSpacesInfo `xml:"space-info"`
		} `xml:"attributes-list"`
		NumRecords string `xml:"num-records"`
	} `xml:"results"`
}

type VolumeSpaceOptions

type VolumeSpaceOptions struct {
	DesiredAttributes *VolumeSpaceInfoQuery `xml:"desired-attributes,omitempty"`
	MaxRecords        int                   `xml:"max-records,omitempty"`
	Query             *VolumeSpaceInfoQuery `xml:"query,omitempty"`
	Tag               string                `xml:"tag,omitempty"`
}

type VolumeSpacesInfo

type VolumeSpacesInfo []VolumeSpaceInfo

func (VolumeSpacesInfo) Len

func (v VolumeSpacesInfo) Len() int

func (VolumeSpacesInfo) Less

func (p VolumeSpacesInfo) Less(i, j int) bool

func (VolumeSpacesInfo) Swap

func (v VolumeSpacesInfo) Swap(i, j int)

type VolumeStateAttributes

type VolumeStateAttributes struct {
	BecomeNodeRootAfterReboot string `xml:"become-node-root-after-reboot"`
	ForceNvfailOnDr           string `xml:"force-nvfail-on-dr"`
	IgnoreInconsistent        string `xml:"ignore-inconsistent"`
	InNvfailedState           string `xml:"in-nvfailed-state"`
	IsClusterVolume           string `xml:"is-cluster-volume"`
	IsConstituent             string `xml:"is-constituent"`
	IsFlexgroup               string `xml:"is-flexgroup"`
	IsInconsistent            string `xml:"is-inconsistent"`
	IsInvalid                 string `xml:"is-invalid"`
	IsJunctionActive          string `xml:"is-junction-active"`
	IsMoving                  string `xml:"is-moving"`
	IsNodeRoot                string `xml:"is-node-root"`
	IsNvfailEnabled           string `xml:"is-nvfail-enabled"`
	IsQuiescedInMemory        string `xml:"is-quiesced-in-memory"`
	IsQuiescedOnDisk          string `xml:"is-quiesced-on-disk"`
	IsUnrecoverable           string `xml:"is-unrecoverable"`
	IsVolumeInCutover         string `xml:"is-volume-in-cutover"`
	IsVserverRoot             string `xml:"is-vserver-root"`
	State                     string `xml:"state"`
}

type VolumeTransitionAttributes

type VolumeTransitionAttributes struct {
	IsCftPrecommit        string `xml:"is-cft-precommit"`
	IsCopiedForTransition string `xml:"is-copied-for-transition"`
	IsTransitioned        string `xml:"is-transitioned"`
	TransitionBehavior    string `xml:"transition-behavior"`
}