fsx

package
v1.7.0 Latest Latest
Warning

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

 Go to latest Published: Oct 6, 2026 License: MIT Imports: 27 Imported by: 0

README

FSx

Parity grade: A · SDK aws-sdk-go-v2/service/fsx@v1.68.4 · last audited 2026-09-30 (6bc42ba0b)

Coverage

Metric Value
Feature families 13 (13 ok)
Known gaps 8
Deferred items 0
Resource leaks clean
Known gaps
  • DescribeDataRepositoryTasks' data-repository-association-id filter is ignored: tasks record no association reference, and CreateDataRepositoryTask accepts none.
  • DescribeSnapshots.IncludeShared is not modeled: this backend is single-account, so no cross-account snapshot exists to differ on.
  • CreateFileSystem does not require SubnetIds and models no AZ topology (exactly two subnets for MULTI_AZ_1); requiring it would migrate every test fixture.
  • ActiveDirectoryError and AD-join state (CreateFileSystem ActiveDirectoryId, Create/UpdateStorageVirtualMachine ActiveDirectoryConfiguration) are not modeled: they need cross-service Directory Service validation.
  • OpenZFSVolumeConfiguration NfsExports, quotas, OriginSnapshot, ParentVolumeId and CopyStrategy/DeleteClonedVolumes remain unmodeled; only unconfigured-volume defaults are emitted.
  • DeleteDataRepositoryAssociation.DeleteDataInFileSystem is not declared: honouring it needs S3 data deletion (unmodeled data-repository subsystem).
  • ClientRequestToken is honoured only by CreateFileSystem; AssociateFileSystemAliases, CopyBackup, CopySnapshotAndUpdateVolume, CreateAndAttachS3AccessPoint, CreateBackup, CreateDataRepositoryAssociation, CreateDataRepositoryTask, CreateFileCache, CreateSnapshot, CreateStorageVirtualMachine, CreateVolume, CreateVolumeFromBackup and RestoreVolumeFromSnapshot accept none, so a retry creates a duplicate; DeleteBackup, DeleteDataRepositoryAssociation, DeleteFileCache, DeleteSnapshot, DeleteStorageVirtualMachine, DeleteVolume, DescribeFileSystemAliases, DetachAndDeleteS3AccessPoint, DisassociateFileSystemAliases, ReleaseFileSystemNfsV3Locks, StartMisconfiguredStateRecovery, UpdateDataRepositoryAssociation, UpdateFileCache, UpdateSharedVpcConfiguration, UpdateSnapshot, UpdateStorageVirtualMachine and UpdateVolume ignore it (those are naturally idempotent).
  • Unmodeled request members: CopyBackup.SourceRegion (cross-region copy), CreateFileCache.SecurityGroupIds/DataRepositoryAssociations/CopyTagsToDataRepositoryAssociations, UpdateFileCache.LustreConfiguration, UpdateFileSystem.StorageType, CreateStorageVirtualMachine.SvmAdminPassword, CopySnapshotAndUpdateVolume.CopyStrategy/Options, RestoreVolumeFromSnapshot.Options, CreateDataRepositoryAssociation.S3 and UpdateDataRepositoryAssociation.S3.

More

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var (
	// ErrFileSystemNotFound is returned when a file system does not exist.
	ErrFileSystemNotFound = awserr.New(errFileSystemNotFound, awserr.ErrNotFound)
	// ErrBackupNotFound is returned when a backup does not exist.
	ErrBackupNotFound = awserr.New(errBackupNotFound, awserr.ErrConflict)
	// ErrValidation is returned on invalid input (wire code: BadRequest).
	ErrValidation = awserr.New(errValidation, awserr.ErrInvalidParameter)
	// ErrMissingFileSystemConfiguration is returned when CreateFileSystem is
	// called for WINDOWS/ONTAP/OPENZFS without the required per-type
	// configuration block (WindowsConfiguration/OntapConfiguration/
	// OpenZFSConfiguration).
	ErrMissingFileSystemConfiguration = awserr.New("MissingFileSystemConfiguration", awserr.ErrInvalidParameter)
	// ErrMissingVolumeConfiguration is returned when CreateVolume is called
	// without the required per-type configuration block (OntapConfiguration
	// for VolumeType=ONTAP, OpenZFSConfiguration for VolumeType=OPENZFS) --
	// real CreateVolumeInput has no top-level FileSystemId/
	// StorageVirtualMachineId at all (fsx@v1.68.4 api_op_CreateVolume.go);
	// types.MissingVolumeConfiguration ("A volume configuration is required
	// for this operation.") is the real wire code for the absent case.
	ErrMissingVolumeConfiguration = awserr.New("MissingVolumeConfiguration", awserr.ErrInvalidParameter)
	// ErrTagInvalid is returned when a tag key or value fails validation.
	ErrTagInvalid = awserr.New("BadRequest", awserr.ErrInvalidParameter)
	// ErrTagLimitExceeded is returned when the 50-tag-per-resource limit is exceeded.
	ErrTagLimitExceeded = awserr.New("ServiceLimitExceeded", awserr.ErrInvalidParameter)

	// ErrSnapshotNotFound is returned when a snapshot does not exist.
	ErrSnapshotNotFound = awserr.New("SnapshotNotFound", awserr.ErrNotFound)
	// ErrStorageVirtualMachineNotFound is returned when an SVM does not exist.
	ErrStorageVirtualMachineNotFound = awserr.New("StorageVirtualMachineNotFound", awserr.ErrNotFound)
	// ErrVolumeNotFound is returned when a volume does not exist.
	ErrVolumeNotFound = awserr.New("VolumeNotFound", awserr.ErrNotFound)
	// ErrFileCacheNotFound is returned when a file cache does not exist.
	ErrFileCacheNotFound = awserr.New("FileCacheNotFound", awserr.ErrNotFound)
	// ErrDataRepositoryAssociationNotFound is returned when a DRA does not exist.
	ErrDataRepositoryAssociationNotFound = awserr.New("DataRepositoryAssociationNotFound", awserr.ErrNotFound)
	// ErrDataRepositoryTaskNotFound is returned when a DRT does not exist.
	ErrDataRepositoryTaskNotFound = awserr.New("DataRepositoryTaskNotFound", awserr.ErrNotFound)
	// ErrS3AccessPointNotFound carries wire code InvalidRequest, a type
	// CreateAndAttachS3AccessPoint's own switch declares (fsx@v1.68.4
	// deserializers.go deserializeOpErrorCreateAndAttachS3AccessPoint) --
	// but no current backend code path emits this sentinel; kept in case a
	// future CreateAndAttachS3AccessPoint validation needs it
	// (gopherstack-6flj/uox6 error-envelope sweep found its only two
	// former callers, in DescribeS3AccessPointAttachments and
	// DetachAndDeleteS3AccessPoint, were wrong -- see
	// ErrS3AccessPointAttachmentNotFound).
	ErrS3AccessPointNotFound = awserr.New("InvalidRequest", awserr.ErrNotFound)
	// ErrS3AccessPointAttachmentNotFound is returned by
	// DescribeS3AccessPointAttachments/DetachAndDeleteS3AccessPoint when the
	// named attachment does not exist. Both ops' own switches declare
	// S3AccessPointAttachmentNotFound, not the InvalidRequest wire code
	// ErrS3AccessPointNotFound carries -- InvalidRequest only fits
	// CreateAndAttachS3AccessPoint's own declared set (gopherstack-6flj/uox6
	// error-envelope sweep).
	ErrS3AccessPointAttachmentNotFound = awserr.New("S3AccessPointAttachmentNotFound", awserr.ErrNotFound)
	// ErrResourceNotFound is returned by the generic Tag/Untag/ListTagsForResource
	// operations when the given ResourceARN does not match any known FSx resource.
	// Real FSx uses the generic ResourceNotFound exception here, distinct from the
	// resource-type-specific *NotFound exceptions used by Describe/Delete ops.
	ErrResourceNotFound = awserr.New("ResourceNotFound", awserr.ErrNotFound)
	// ErrIncompatibleParameter is returned by CreateFileSystem when a second
	// request is received with a previously-used ClientRequestToken but
	// different parameter settings.
	ErrIncompatibleParameter = awserr.New("IncompatibleParameterError", awserr.ErrInvalidParameter)
	// ErrInvalidNetworkSettings is returned when a SubnetId/SecurityGroupId
	// supplied to CreateFileSystem doesn't match the real ID format.
	ErrInvalidNetworkSettings = awserr.New("InvalidNetworkSettings", awserr.ErrInvalidParameter)
	// ErrDataRepositoryTaskExecuting is returned by CreateDataRepositoryTask
	// when the target file system already has a task with Lifecycle
	// EXECUTING (fsx@v1.68.4 types/errors.go: "An existing data repository
	// task is currently executing on the file system. Wait until the
	// existing task has completed, then create the new task.").
	ErrDataRepositoryTaskExecuting = awserr.New("DataRepositoryTaskExecuting", awserr.ErrInvalidParameter)
	// ErrMissingFileCacheConfiguration is returned when CreateFileCache is
	// called without the required LustreConfiguration block (fsx@v1.68.4
	// types/errors.go: "A cache configuration is required for this
	// operation." -- FileCacheType is always LUSTRE, so this is the only
	// per-type config block CreateFileCache has).
	ErrMissingFileCacheConfiguration = awserr.New("MissingFileCacheConfiguration", awserr.ErrInvalidParameter)
)
View Source 
var ErrNilAppContext = errors.New("fsx: nil app context")

ErrNilAppContext is returned when Init is called with a nil AppContext.

Functions

This section is empty.

Types

type AdministrativeAction added in v1.5.0 

type AdministrativeAction struct {
	RequestTime              epochTime `json:"RequestTime"`
	TargetVolumeValues       *Volume   `json:"TargetVolumeValues,omitempty"`
	AdministrativeActionType string    `json:"AdministrativeActionType,omitempty"`
	Status                   string    `json:"Status,omitempty"`
}

AdministrativeAction represents an in-progress or completed FSx administrative action (types.AdministrativeAction, deserializers.go:7516). RestoreVolumeFromSnapshot and CopySnapshotAndUpdateVolume wrap their response under "AdministrativeActions" (plus root-level Lifecycle/VolumeId) -- not under a "Volume" key, which neither op's real Output struct has at all (api_op_RestoreVolumeFromSnapshot.go, api_op_CopySnapshotAndUpdateVolume.go).

type Backup 

type Backup struct {
	CreationTime epochTime   `json:"CreationTime"`
	FileSystem   *FileSystem `json:"FileSystem,omitempty"`
	Volume       *Volume     `json:"Volume,omitempty"`
	BackupID     string      `json:"BackupId"`
	BackupType   string      `json:"Type"`
	Lifecycle    string      `json:"Lifecycle"`
	ResourceARN  string      `json:"ResourceARN"`
	KmsKeyID     string      `json:"KmsKeyId,omitempty"`
	Tags         []Tag       `json:"Tags,omitempty"`
}

Backup represents an Amazon FSx backup. CreationTime is first so its non-pointer prefix reduces GC pointer bytes.

type CompletionReport added in v1.3.1 

type CompletionReport struct {
	Enabled *bool  `json:"Enabled"`
	Format  string `json:"Format,omitempty"`
	Path    string `json:"Path,omitempty"`
	Scope   string `json:"Scope,omitempty"`
}

CompletionReport mirrors types.CompletionReport (types.go:468). Enabled is the only required member (validateCompletionReport, validators.go); Format/Path/Scope are "required if Enabled is true" per doc comment only, not enforced by the SDK's own client-side validator, so this backend doesn't enforce them either.

type DataRepositoryAssociation 

type DataRepositoryAssociation struct {
	CreationTime          epochTime `json:"CreationTime"`
	AssociationID         string    `json:"AssociationId"`
	FileSystemID          string    `json:"FileSystemId"`
	FileSystemPath        string    `json:"FileSystemPath"`
	DataRepositoryPath    string    `json:"DataRepositoryPath"`
	Lifecycle             string    `json:"Lifecycle"`
	ResourceARN           string    `json:"ResourceARN"`
	Tags                  []Tag     `json:"Tags,omitempty"`
	ImportedFileChunkSize int32     `json:"ImportedFileChunkSize,omitempty"`
}

DataRepositoryAssociation links a file system path to an S3 data repository. CreationTime is first so its non-pointer prefix reduces GC pointer bytes. CreationTime uses epochTime: the real FSx deserializer requires a JSON number of epoch seconds here, not an RFC3339 string.

type DataRepositoryConfiguration 

type DataRepositoryConfiguration struct {
	Lifecycle        string `json:"Lifecycle,omitempty"`
	AutoImportPolicy string `json:"AutoImportPolicy,omitempty"`
	ImportPath       string `json:"ImportPath,omitempty"`
	ExportPath       string `json:"ExportPath,omitempty"`
}

DataRepositoryConfiguration describes the data repository linkage for a Lustre file system. AWS returns this block (with a Lifecycle) on every Lustre file system, even when no S3 repository is linked.

type DataRepositoryTask 

type DataRepositoryTask struct {
	CreationTime         epochTime                 `json:"CreationTime"`
	EndTime              *epochTime                `json:"EndTime,omitempty"`
	Report               *CompletionReport         `json:"Report,omitempty"`
	Status               *DataRepositoryTaskStatus `json:"Status,omitempty"`
	CapacityToRelease    *int64                    `json:"CapacityToRelease,omitempty"`
	ReleaseConfiguration *ReleaseConfiguration     `json:"ReleaseConfiguration,omitempty"`
	TaskID               string                    `json:"TaskId"`
	FileSystemID         string                    `json:"FileSystemId"`
	Type                 string                    `json:"Type"`
	Lifecycle            string                    `json:"Lifecycle"`
	ResourceARN          string                    `json:"ResourceARN"`
	Paths                []string                  `json:"Paths,omitempty"`
	Tags                 []Tag                     `json:"Tags,omitempty"`
}

DataRepositoryTask represents a task that moves data between FSx and a data repository. CreationTime is first so its non-pointer prefix reduces GC pointer bytes. CreationTime uses epochTime: the real FSx deserializer requires a JSON number of epoch seconds here, not an RFC3339 string.

type DataRepositoryTaskStatus 

type DataRepositoryTaskStatus struct {
	LastUpdatedTime epochTime `json:"LastUpdatedTime"`
	TotalCount      int64     `json:"TotalCount"`
	SucceededCount  int64     `json:"SucceededCount"`
	FailedCount     int64     `json:"FailedCount"`
}

DataRepositoryTaskStatus mirrors types.DataRepositoryTaskStatus (types/types.go:2041). ReleasedCapacity (AUTO_RELEASE_DATA / File Cache tasks only) is not modeled: this backend has no File Cache release engine.

type DurationSinceLastAccess 

type DurationSinceLastAccess struct {
	Value *int64 `json:"Value,omitempty"`
	Unit  string `json:"Unit,omitempty"`
}

DurationSinceLastAccess is the minimum time since a file was last accessed.

type FileCache 

type FileCache struct {
	CreationTime         epochTime                     `json:"CreationTime"`
	LustreConfiguration  *FileCacheLustreConfiguration `json:"LustreConfiguration,omitempty"`
	FileCacheID          string                        `json:"FileCacheId"`
	FileCacheType        string                        `json:"FileCacheType"`
	FileCacheTypeVersion string                        `json:"FileCacheTypeVersion,omitempty"`
	KmsKeyID             string                        `json:"KmsKeyId,omitempty"`
	Lifecycle            string                        `json:"Lifecycle"`
	ResourceARN          string                        `json:"ResourceARN"`
	SubnetIDs            []string                      `json:"SubnetIds,omitempty"`
	StorageCapacityGiB   int32                         `json:"StorageCapacity,omitempty"`
}

FileCache represents an Amazon FSx file cache, in the shape used by DescribeFileCaches/UpdateFileCache (types.FileCache, types/types.go:2264). Unlike FileCacheCreating below, this type has no Tags member: the real deserializer (deserializers.go:9818) has no case "Tags" at all, so a real client would silently drop that key. CreationTime is first so its non-pointer prefix reduces GC pointer bytes. CreationTime uses epochTime: the real FSx deserializer requires a JSON number of epoch seconds here, not an RFC3339 string.

type FileCacheCreating added in v1.5.0 

type FileCacheCreating struct {
	CreationTime         epochTime                     `json:"CreationTime"`
	LustreConfiguration  *FileCacheLustreConfiguration `json:"LustreConfiguration,omitempty"`
	FileCacheID          string                        `json:"FileCacheId"`
	FileCacheType        string                        `json:"FileCacheType"`
	FileCacheTypeVersion string                        `json:"FileCacheTypeVersion,omitempty"`
	KmsKeyID             string                        `json:"KmsKeyId,omitempty"`
	Lifecycle            string                        `json:"Lifecycle"`
	ResourceARN          string                        `json:"ResourceARN"`
	SubnetIDs            []string                      `json:"SubnetIds,omitempty"`
	Tags                 []Tag                         `json:"Tags,omitempty"`
	StorageCapacityGiB   int32                         `json:"StorageCapacity,omitempty"`
}

FileCacheCreating represents the CreateFileCache response shape (types.FileCacheCreating, types/types.go:2349) which, unlike FileCache above, DOES include Tags (deserializers.go:9984, case "Tags").

type FileCacheLustreConfiguration 

type FileCacheLustreConfiguration struct {
	MetadataConfiguration      *FileCacheLustreMetadataConfiguration `json:"MetadataConfiguration,omitempty"`
	DeploymentType             string                                `json:"DeploymentType,omitempty"`
	MountName                  string                                `json:"MountName,omitempty"`
	WeeklyMaintenanceStartTime string                                `json:"WeeklyMaintenanceStartTime,omitempty"`
	PerUnitStorageThroughput   int32                                 `json:"PerUnitStorageThroughput,omitempty"`
}

FileCacheLustreConfiguration describes the Lustre-specific configuration of an FSx file cache. Real AWS always returns this block (types.FileCacheLustreConfiguration, types/types.go:2514) for a LUSTRE cache, with at least DeploymentType, MetadataConfiguration, and PerUnitStorageThroughput populated. LogConfiguration is not modeled here (no logging destination is configurable on this backend).

type FileCacheLustreMetadataConfiguration 

type FileCacheLustreMetadataConfiguration struct {
	StorageCapacity int32 `json:"StorageCapacity,omitempty"`
}

FileCacheLustreMetadataConfiguration describes the Lustre MDT (Metadata Target) storage volume for a file cache (types.FileCacheLustreMetadataConfiguration, types/types.go:2550).

type FileSystem 

type FileSystem struct {
	CreationTime          epochTime             `json:"CreationTime"`
	LustreConfiguration   *LustreConfiguration  `json:"LustreConfiguration,omitempty"`
	WindowsConfiguration  *WindowsConfiguration `json:"WindowsConfiguration,omitempty"`
	OntapConfiguration    *OntapConfiguration   `json:"OntapConfiguration,omitempty"`
	OpenZFSConfiguration  *OpenZFSConfiguration `json:"OpenZFSConfiguration,omitempty"`
	FileSystemID          string                `json:"FileSystemId"`
	FileSystemType        string                `json:"FileSystemType"`
	FileSystemTypeVersion string                `json:"FileSystemTypeVersion,omitempty"`
	Lifecycle             string                `json:"Lifecycle"`
	ResourceARN           string                `json:"ResourceARN"`
	DNSName               string                `json:"DNSName,omitempty"`
	KmsKeyID              string                `json:"KmsKeyId,omitempty"`
	StorageType           string                `json:"StorageType,omitempty"`
	VpcID                 string                `json:"VpcId,omitempty"`
	OwnersID              string                `json:"OwnerId,omitempty"`
	SubnetIDs             []string              `json:"SubnetIds,omitempty"`
	NetworkInterfaceIDs   []string              `json:"NetworkInterfaceIds,omitempty"`
	NetworkType           string                `json:"NetworkType,omitempty"`
	Tags                  []Tag                 `json:"Tags,omitempty"`
	StorageCapacityGiB    int32                 `json:"StorageCapacity,omitempty"`
}

FileSystem represents an Amazon FSx file system. CreationTime is first so its non-pointer prefix reduces GC pointer bytes.

type FileSystemAlias 

type FileSystemAlias struct {
	Name      string `json:"Name"`
	Lifecycle string `json:"Lifecycle"`
}

FileSystemAlias represents an FSx file-system DNS alias.

type FileSystemEndpoint added in v1.2.0 

type FileSystemEndpoint struct {
	DNSName string `json:"DNSName,omitempty"`
}

FileSystemEndpoint is a single DNS endpoint on an ONTAP file system.

type FileSystemEndpoints added in v1.2.0 

type FileSystemEndpoints struct {
	Intercluster *FileSystemEndpoint `json:"Intercluster,omitempty"`
	Management   *FileSystemEndpoint `json:"Management,omitempty"`
}

FileSystemEndpoints holds the ONTAP management/intercluster endpoints used to access data or manage the file system.

type Handler 

type Handler struct {
	Backend StorageBackend
	// contains filtered or unexported fields
}

Handler handles FSx HTTP requests.

func NewHandler 

func NewHandler(b StorageBackend) *Handler

NewHandler constructs a new Handler.

func (*Handler) BackendFor 

func (h *Handler) BackendFor(region string) StorageBackend

BackendFor returns the backend serving region: the home backend, or the sibling built on first use.

func (*Handler) EnableRegions 

func (h *Handler) EnableRegions()

EnableRegions makes h serve every other region through lazily built per-region siblings.

func (*Handler) ExtractOperation 

func (h *Handler) ExtractOperation(c *echo.Context) string

ExtractOperation extracts the FSx operation from the X-Amz-Target header.

func (*Handler) ExtractResource 

func (h *Handler) ExtractResource(c *echo.Context) string

ExtractResource extracts a resource identifier from the request body.

func (*Handler) GetSupportedOperations 

func (h *Handler) GetSupportedOperations() []string

GetSupportedOperations returns the list of supported operations.

func (*Handler) Handler 

func (h *Handler) Handler() echo.HandlerFunc

Handler returns the echo handler func.

func (*Handler) MatchPriority 

func (h *Handler) MatchPriority() int

MatchPriority returns the routing priority.

func (*Handler) Name 

func (h *Handler) Name() string

Name returns the service name.

func (*Handler) RegionBackends 

func (h *Handler) RegionBackends() []StorageBackend

RegionBackends returns the home backend followed by every sibling built so far.

func (*Handler) RegionHandler 

func (h *Handler) RegionHandler(region string) *Handler

RegionHandler returns the handler serving region: h itself for the home region, else its sibling.

func (*Handler) Reset 

func (h *Handler) Reset()

Reset resets the backend.

func (*Handler) Restore 

func (h *Handler) Restore(ctx context.Context, data []byte) error

Restore implements persistence.Persistable.

func (*Handler) RouteMatcher 

func (h *Handler) RouteMatcher() service.Matcher

RouteMatcher returns a matcher that accepts FSx requests by X-Amz-Target.

func (*Handler) Snapshot 

func (h *Handler) Snapshot(ctx context.Context) []byte

Snapshot implements persistence.Persistable; other regions ride in an additive "regions" key.

type InMemoryBackend 

type InMemoryBackend struct {
	// contains filtered or unexported fields
}

InMemoryBackend implements StorageBackend using in-memory maps.

func NewInMemoryBackend 

func NewInMemoryBackend(accountID, region string) *InMemoryBackend

NewInMemoryBackend constructs a new InMemoryBackend.

func (*InMemoryBackend) AccountID 

func (b *InMemoryBackend) AccountID() string

AccountID returns the configured AWS account ID.

func (*InMemoryBackend) AssociateFileSystemAliases 

func (b *InMemoryBackend) AssociateFileSystemAliases(fileSystemID string, aliases []string) ([]FileSystemAlias, error)

AssociateFileSystemAliases adds DNS aliases to a file system.

func (*InMemoryBackend) CancelDataRepositoryTask 

func (b *InMemoryBackend) CancelDataRepositoryTask(taskID string) error

CancelDataRepositoryTask marks a task as cancelled. It settles at the terminal CANCELED on the next sweep (the next Cancel/Create/Describe call), matching the transient CANCELING window a real client observes before AWS finishes tearing the task down.

func (*InMemoryBackend) CopyBackup 

func (b *InMemoryBackend) CopyBackup(input *copyBackupInput) (*Backup, error)

CopyBackup creates a copy of an existing backup.

func (*InMemoryBackend) CopySnapshotAndUpdateVolume 

func (b *InMemoryBackend) CopySnapshotAndUpdateVolume(input *copySnapshotAndUpdateVolumeInput) (*Volume, error)

CopySnapshotAndUpdateVolume restores a volume to the state of a snapshot. SourceSnapshotARN is a required real CopySnapshotAndUpdateVolumeInput member (api_op_CopySnapshotAndUpdateVolume.go) that was previously decoded but never read anywhere: any ARN, including one naming a nonexistent snapshot, silently succeeded. Now resolved and existence-checked like RestoreVolumeFromSnapshot's sibling SnapshotId parameter.

Neither not-found check below uses ErrVolumeNotFound/ErrSnapshotNotFound: this op's own switch (fsx@v1.68.4 deserializers.go deserializeOpErrorCopySnapshotAndUpdateVolume) is exactly [BadRequest, IncompatibleParameterError, InternalServerError, ServiceLimitExceeded] -- neither NotFound type is declared here, unlike their legitimate declarers elsewhere in this service. ErrValidation (BadRequest, "a generic error indicating a failure with a client request") is this op's own declared generic-client-error type and is the correct substitution, not an invented code (gopherstack-6flj/uox6 error-envelope sweep).

func (*InMemoryBackend) CreateAndAttachS3AccessPoint 

func (b *InMemoryBackend) CreateAndAttachS3AccessPoint(
	input *createAndAttachS3AccessPointInput,
) (*S3AccessPointAttachment, error)

CreateAndAttachS3AccessPoint creates and attaches an S3 access point to an ONTAP or OpenZFS volume. Real AWS input has no top-level FileSystemId or Tags -- the attached volume is nested under whichever of OntapConfiguration/OpenZFSConfiguration matches Type (api_op_CreateAndAttachS3AccessPoint.go:52).

func (*InMemoryBackend) CreateBackup 

func (b *InMemoryBackend) CreateBackup(input *createBackupInput) (*Backup, error)

CreateBackup creates a backup of the specified file system.

func (*InMemoryBackend) CreateDataRepositoryAssociation 

func (b *InMemoryBackend) CreateDataRepositoryAssociation(
	input *createDataRepositoryAssociationInput,
) (*DataRepositoryAssociation, error)

CreateDataRepositoryAssociation creates a data repository association.

func (*InMemoryBackend) CreateDataRepositoryTask 

func (b *InMemoryBackend) CreateDataRepositoryTask(input *createDataRepositoryTaskInput) (*DataRepositoryTask, error)

CreateDataRepositoryTask creates a data repository task. Report is a required CreateDataRepositoryTaskInput member (verified against validateOpCreateDataRepositoryTaskInput, validators.go), and its own Enabled member is required whenever Report is present (validateCompletionReport) -- the pre-fix request never read Report at all.

func (*InMemoryBackend) CreateFileCache 

func (b *InMemoryBackend) CreateFileCache(input *createFileCacheInput) (*FileCacheCreating, error)

CreateFileCache creates a file cache. FileCacheTypeVersion and SubnetIds are, along with FileCacheType/StorageCapacity, required CreateFileCacheInput members (verified against validateOpCreateFileCacheInput, validators.go) that the pre-fix request never read at all -- StorageCapacity was already wired.

func (*InMemoryBackend) CreateFileSystem 

func (b *InMemoryBackend) CreateFileSystem(input *createFileSystemInput) (*FileSystem, error)

CreateFileSystem creates a new file system. A non-empty ClientRequestToken makes the call idempotent: a repeat call with the same token and the same parameters returns the original file system instead of creating a second one; a repeat call with the same token but different parameters returns IncompatibleParameterError (see dedupCreateFileSystemLocked).

func (*InMemoryBackend) CreateFileSystemFromBackup 

func (b *InMemoryBackend) CreateFileSystemFromBackup(input *createFileSystemFromBackupInput) (*FileSystem, error)

CreateFileSystemFromBackup creates a new file system from an existing backup.

func (*InMemoryBackend) CreateSnapshot 

func (b *InMemoryBackend) CreateSnapshot(input *createSnapshotInput) (*Snapshot, error)

CreateSnapshot creates a snapshot of a volume.

func (*InMemoryBackend) CreateStorageVirtualMachine 

func (b *InMemoryBackend) CreateStorageVirtualMachine(
	input *createStorageVirtualMachineInput,
) (*StorageVirtualMachine, error)

CreateStorageVirtualMachine creates an SVM on an ONTAP file system.

func (*InMemoryBackend) CreateVolume 

func (b *InMemoryBackend) CreateVolume(input *createVolumeInput) (*Volume, error)

CreateVolume creates a volume. Real AWS requires OntapConfiguration for VolumeType=ONTAP and OpenZFSConfiguration for VolumeType=OPENZFS (types.MissingVolumeConfiguration, "A volume configuration is required for this operation.") -- there is no other way for a real client to name the parent file system, since CreateVolumeInput carries neither a FileSystemId nor a top-level StorageVirtualMachineId.

func (*InMemoryBackend) CreateVolumeFromBackup 

func (b *InMemoryBackend) CreateVolumeFromBackup(input *createVolumeFromBackupInput) (*Volume, error)

CreateVolumeFromBackup creates an ONTAP volume from a backup. Real AWS requires OntapConfiguration.StorageVirtualMachineId to name the target SVM (types.MissingVolumeConfiguration otherwise) -- there is no other way for a real client to specify it, since CreateVolumeFromBackupInput carries no top-level StorageVirtualMachineId.

func (*InMemoryBackend) DeleteBackup 

func (b *InMemoryBackend) DeleteBackup(backupID string) error

DeleteBackup removes a backup.

func (*InMemoryBackend) DeleteDataRepositoryAssociation 

func (b *InMemoryBackend) DeleteDataRepositoryAssociation(associationID string) error

DeleteDataRepositoryAssociation removes a data repository association.

func (*InMemoryBackend) DeleteFileCache 

func (b *InMemoryBackend) DeleteFileCache(fileCacheID string) error

DeleteFileCache removes a file cache.

func (*InMemoryBackend) DeleteFileSystem 

func (b *InMemoryBackend) DeleteFileSystem(in *deleteFileSystemInput) (*deleteFileSystemOutput, error)

DeleteFileSystem removes a file system, cascading to children and taking the documented default final backup.

func (*InMemoryBackend) DeleteSnapshot 

func (b *InMemoryBackend) DeleteSnapshot(snapshotID string) error

DeleteSnapshot removes a snapshot.

func (*InMemoryBackend) DeleteStorageVirtualMachine 

func (b *InMemoryBackend) DeleteStorageVirtualMachine(svmID string) error

DeleteStorageVirtualMachine removes an SVM. Real AWS: "Prior to deleting an SVM, you must delete all non-root volumes in the SVM, otherwise the operation will fail".

func (*InMemoryBackend) DeleteVolume 

func (b *InMemoryBackend) DeleteVolume(in *deleteVolumeInput) (*deleteVolumeOutput, error)

DeleteVolume removes a volume.

func (*InMemoryBackend) DescribeBackups 

func (b *InMemoryBackend) DescribeBackups(
	backupIDs []string,
	filters []wireFilter,
	maxResults int32,
	nextToken string,
) ([]*Backup, string, error)

DescribeBackups returns backups, optionally filtered by IDs or Filters. Per DescribeBackupsInput's own doc comment, BackupIds overrides Filters entirely when both are set.

func (*InMemoryBackend) DescribeDataRepositoryAssociations 

func (b *InMemoryBackend) DescribeDataRepositoryAssociations(
	ids []string,
	filters []wireFilter,
	maxResults int32,
	nextToken string,
) ([]*DataRepositoryAssociation, string, error)

DescribeDataRepositoryAssociations returns DRAs, optionally filtered by ID or Filters. Real DescribeDataRepositoryAssociationsInput.Filters (aws-sdk-go-v2/service/fsx@v1.68.4 api_op_DescribeDataRepositoryAssociations.go) reuses the same types.Filter/FilterName as DescribeBackups, but a DRA has no backup-type/volume-id/file-cache-* concept of its own -- only file-system-id is recognized here; the other enum values are honored as documented-but-unsupported (matches everything, same as an unset filter).

func (*InMemoryBackend) DescribeDataRepositoryTasks 

func (b *InMemoryBackend) DescribeDataRepositoryTasks(
	ids []string,
	filters []wireFilter,
	maxResults int32,
	nextToken string,
) ([]*DataRepositoryTask, string, error)

DescribeDataRepositoryTasks returns tasks filtered by ID or Filters. Tasks never target a file cache, so file-cache-id matches none.

func (*InMemoryBackend) DescribeFileCaches 

func (b *InMemoryBackend) DescribeFileCaches(
	ids []string,
	maxResults int32,
	nextToken string,
) ([]*FileCache, string, error)

DescribeFileCaches returns file caches, optionally filtered by ID.

func (*InMemoryBackend) DescribeFileSystemAliases 

func (b *InMemoryBackend) DescribeFileSystemAliases(
	fileSystemID string,
	maxResults int32,
	nextToken string,
) ([]FileSystemAlias, string, error)

DescribeFileSystemAliases returns aliases for a file system.

func (*InMemoryBackend) DescribeFileSystems 

func (b *InMemoryBackend) DescribeFileSystems(
	ids []string,
	maxResults int32,
	nextToken string,
) ([]*FileSystem, string, error)

DescribeFileSystems returns file systems, optionally filtered by IDs.

func (*InMemoryBackend) DescribeS3AccessPointAttachments 

func (b *InMemoryBackend) DescribeS3AccessPointAttachments(
	names []string,
	filters []wireFilter,
	maxResults int32,
	nextToken string,
) ([]*S3AccessPointAttachment, string, error)

DescribeS3AccessPointAttachments returns S3 access point attachments, optionally filtered by Name or Filters. Real S3AccessPointAttachmentsFilterName (aws-sdk-go-v2/service/fsx@v1.68.4 types/enums.go) has 3 values: file-system-id, volume-id, type. file-system-id requires resolving the attachment's owning volume -- storedS3AccessPoint only tracks VolumeID directly.

func (*InMemoryBackend) DescribeSharedVpcConfiguration 

func (b *InMemoryBackend) DescribeSharedVpcConfiguration() (*SharedVpcConfiguration, error)

DescribeSharedVpcConfiguration returns the shared VPC configuration.

func (*InMemoryBackend) DescribeSnapshots 

func (b *InMemoryBackend) DescribeSnapshots(
	ids []string,
	filters []wireFilter,
	maxResults int32,
	nextToken string,
) ([]*Snapshot, string, error)

DescribeSnapshots returns snapshots, optionally filtered by ID or Filters. Real SnapshotFilterName (aws-sdk-go-v2/service/fsx@v1.68.4 types/enums.go) has 2 values: file-system-id, volume-id. file-system-id requires resolving the snapshot's owning volume -- storedSnapshot only tracks VolumeID directly. IncludeShared (real DescribeSnapshotsInput member) is not modeled: this backend is single-account/single-tenant, so every snapshot is definitionally "owned" regardless of that flag -- there is no honest cross-account snapshot to differ on.

func (*InMemoryBackend) DescribeStorageVirtualMachines 

func (b *InMemoryBackend) DescribeStorageVirtualMachines(
	ids []string,
	filters []wireFilter,
	maxResults int32,
	nextToken string,
) ([]*StorageVirtualMachine, string, error)

DescribeStorageVirtualMachines returns SVMs, optionally filtered by ID or Filters. Real StorageVirtualMachineFilterName (aws-sdk-go-v2/service/fsx@v1.68.4 types/enums.go) has exactly one value, file-system-id.

func (*InMemoryBackend) DescribeVolumes 

func (b *InMemoryBackend) DescribeVolumes(
	ids []string,
	filters []wireFilter,
	maxResults int32,
	nextToken string,
) ([]*Volume, string, error)

DescribeVolumes returns volumes, optionally filtered by ID or Filters. Real VolumeFilterName (aws-sdk-go-v2/service/fsx@v1.68.4 types/enums.go) has 2 values: file-system-id, storage-virtual-machine-id -- both tracked directly on storedVolume.

func (*InMemoryBackend) DetachAndDeleteS3AccessPoint 

func (b *InMemoryBackend) DetachAndDeleteS3AccessPoint(name string) error

DetachAndDeleteS3AccessPoint removes an S3 access point. Real AWS's DetachAndDeleteS3AccessPointInput has no FileSystemId member at all (api_op_DetachAndDeleteS3AccessPoint.go:36) -- Name alone identifies it.

func (*InMemoryBackend) DisassociateFileSystemAliases 

func (b *InMemoryBackend) DisassociateFileSystemAliases(
	fileSystemID string,
	aliases []string,
) ([]FileSystemAlias, error)

DisassociateFileSystemAliases removes DNS aliases from a file system.

func (*InMemoryBackend) ListTagsForResource 

func (b *InMemoryBackend) ListTagsForResource(resourceARN string) ([]Tag, error)

ListTagsForResource returns the tags on a resource.

func (*InMemoryBackend) Region 

func (b *InMemoryBackend) Region() string

Region returns the configured AWS region.

func (*InMemoryBackend) ReleaseFileSystemNfsV3Locks 

func (b *InMemoryBackend) ReleaseFileSystemNfsV3Locks(fileSystemID string) error

ReleaseFileSystemNfsV3Locks releases NFS v3 locks on a file system.

func (*InMemoryBackend) Reset 

func (b *InMemoryBackend) Reset()

Reset clears all stored state.

func (*InMemoryBackend) Restore 

func (b *InMemoryBackend) Restore(ctx context.Context, data []byte) error

Restore deserializes backend state from JSON. It implements persistence.Persistable.

func (*InMemoryBackend) RestoreVolumeFromSnapshot 

func (b *InMemoryBackend) RestoreVolumeFromSnapshot(input *restoreVolumeFromSnapshotInput) (*Volume, error)

RestoreVolumeFromSnapshot restores a volume to a snapshot state.

The VolumeId check below stays on ErrVolumeNotFound -- this op's own switch (fsx@v1.68.4 deserializers.go deserializeOpErrorRestoreVolumeFromSnapshot) is [BadRequest, InternalServerError, VolumeNotFound], which declares it. SnapshotNotFound is not declared here (unlike its legitimate declarers DeleteSnapshot/DescribeSnapshots/UpdateSnapshot), so the SnapshotId check uses ErrValidation (BadRequest) instead, this op's own declared generic-client-error type (gopherstack-6flj/uox6 error-envelope sweep).

func (*InMemoryBackend) Snapshot 

func (b *InMemoryBackend) Snapshot(ctx context.Context) []byte

Snapshot serializes backend state to JSON. It implements persistence.Persistable.

func (*InMemoryBackend) StartMisconfiguredStateRecovery 

func (b *InMemoryBackend) StartMisconfiguredStateRecovery(fileSystemID string) error

StartMisconfiguredStateRecovery initiates recovery for a misconfigured file system.

func (*InMemoryBackend) TagResource 

func (b *InMemoryBackend) TagResource(resourceARN string, tags []Tag) error

TagResource adds or updates tags on a resource.

The tag-limit check below uses ErrValidation (BadRequest), not ErrTagLimitExceeded: TagResource's own switch (fsx@v1.68.4 deserializers.go deserializeOpErrorTagResource) is [BadRequest, InternalServerError, NotServiceResourceError, ResourceDoesNotSupportTagging, ResourceNotFound] -- ServiceLimitExceeded is not declared here, unlike its legitimate declarers CopyBackup/CopySnapshotAndUpdateVolume/CreateBackup/ CreateDataRepositoryAssociation/CreateDataRepositoryTask. Neither NotServiceResourceError nor ResourceDoesNotSupportTagging fit "too many tags" by their own doc comments (types/errors.go), so BadRequest -- this op's own declared generic-client-error type -- is the correct substitution (gopherstack-6flj/uox6 error-envelope sweep).

func (*InMemoryBackend) UntagResource 

func (b *InMemoryBackend) UntagResource(resourceARN string, tagKeys []string) error

UntagResource removes tags from a resource.

func (*InMemoryBackend) UpdateDataRepositoryAssociation 

func (b *InMemoryBackend) UpdateDataRepositoryAssociation(
	input *updateDataRepositoryAssociationInput,
) (*DataRepositoryAssociation, error)

UpdateDataRepositoryAssociation updates a DRA's paths.

func (*InMemoryBackend) UpdateFileCache 

func (b *InMemoryBackend) UpdateFileCache(input *updateFileCacheInput) (*FileCache, error)

UpdateFileCache updates a file cache.

func (*InMemoryBackend) UpdateFileSystem 

func (b *InMemoryBackend) UpdateFileSystem(input *updateFileSystemInput) (*FileSystem, error)

UpdateFileSystem updates a file system's configuration.

func (*InMemoryBackend) UpdateSharedVpcConfiguration 

func (b *InMemoryBackend) UpdateSharedVpcConfiguration(
	input *updateSharedVpcConfigurationInput,
) (*SharedVpcConfiguration, error)

UpdateSharedVpcConfiguration updates the shared VPC configuration.

func (*InMemoryBackend) UpdateSnapshot 

func (b *InMemoryBackend) UpdateSnapshot(input *updateSnapshotInput) (*Snapshot, error)

UpdateSnapshot updates snapshot metadata.

func (*InMemoryBackend) UpdateStorageVirtualMachine 

func (b *InMemoryBackend) UpdateStorageVirtualMachine(
	input *updateStorageVirtualMachineInput,
) (*StorageVirtualMachine, error)

UpdateStorageVirtualMachine updates an SVM. SvmAdminPassword is accepted (matching the real op's only scalar updatable field) but not persisted: real AWS never echoes it back on any Describe/Update response either (write-only credential), so there is no observable difference between storing and dropping it.

func (*InMemoryBackend) UpdateVolume 

func (b *InMemoryBackend) UpdateVolume(input *updateVolumeInput) (*Volume, error)

UpdateVolume updates volume metadata.

type LustreConfiguration 

type LustreConfiguration struct {
	DataRepositoryConfiguration *DataRepositoryConfiguration `json:"DataRepositoryConfiguration,omitempty"`
	DeploymentType              string                       `json:"DeploymentType,omitempty"`
	DataCompressionType         string                       `json:"DataCompressionType,omitempty"`
	DriveCacheType              string                       `json:"DriveCacheType,omitempty"`
	MountName                   string                       `json:"MountName,omitempty"`
	WeeklyMaintenanceStartTime  string                       `json:"WeeklyMaintenanceStartTime,omitempty"`
	PerUnitStorageThroughput    int32                        `json:"PerUnitStorageThroughput,omitempty"`
}

LustreConfiguration describes the Lustre-specific configuration of an FSx file system. AWS always returns this block (with at least DeploymentType, MountName, and DataRepositoryConfiguration) for Lustre file systems.

type OntapConfiguration added in v1.2.0 

type OntapConfiguration struct {
	Endpoints                     *FileSystemEndpoints `json:"Endpoints,omitempty"`
	DailyAutomaticBackupStartTime string               `json:"DailyAutomaticBackupStartTime,omitempty"`
	DeploymentType                string               `json:"DeploymentType,omitempty"`
	EndpointIPAddressRange        string               `json:"EndpointIpAddressRange,omitempty"`
	PreferredSubnetID             string               `json:"PreferredSubnetId,omitempty"`
	AutomaticBackupRetentionDays  int32                `json:"AutomaticBackupRetentionDays,omitempty"`
	HAPairs                       int32                `json:"HAPairs,omitempty"`
	ThroughputCapacity            int32                `json:"ThroughputCapacity,omitempty"`
	ThroughputCapacityPerHAPair   int32                `json:"ThroughputCapacityPerHAPair,omitempty"`
}

OntapConfiguration describes the FSx for NetApp ONTAP-specific configuration of an FSx file system. Real AWS always returns this block for ONTAP file systems, with at least DeploymentType populated.

type OntapVolumeConfiguration 

type OntapVolumeConfiguration struct {
	StorageVirtualMachineID string `json:"StorageVirtualMachineId,omitempty"`
}

OntapVolumeConfiguration is the ONTAP-specific block on Volume (types.OntapVolumeConfiguration, types/types.go). Only StorageVirtualMachineId is modeled -- the remaining real members (JunctionPath, SizeInBytes, SecurityStyle, OntapVolumeType, SnaplockConfiguration, TieringPolicy, ...) stay a disclosed, unmodeled gap (see PARITY.md).

type OpenZFSConfiguration added in v1.2.0 

type OpenZFSConfiguration struct {
	DailyAutomaticBackupStartTime string `json:"DailyAutomaticBackupStartTime,omitempty"`
	DeploymentType                string `json:"DeploymentType,omitempty"`
	PreferredSubnetID             string `json:"PreferredSubnetId,omitempty"`
	RootVolumeID                  string `json:"RootVolumeId,omitempty"`
	WeeklyMaintenanceStartTime    string `json:"WeeklyMaintenanceStartTime,omitempty"`
	AutomaticBackupRetentionDays  int32  `json:"AutomaticBackupRetentionDays,omitempty"`
	ThroughputCapacity            int32  `json:"ThroughputCapacity,omitempty"`
	CopyTagsToBackups             bool   `json:"CopyTagsToBackups,omitempty"`
	CopyTagsToVolumes             bool   `json:"CopyTagsToVolumes,omitempty"`
}

OpenZFSConfiguration describes the FSx for OpenZFS-specific configuration of an FSx file system. Real AWS always returns this block for OPENZFS file systems, with at least DeploymentType and RootVolumeId populated.

type OpenZFSVolumeConfiguration 

type OpenZFSVolumeConfiguration struct {
	DataCompressionType string `json:"DataCompressionType,omitempty"`
	VolumePath          string `json:"VolumePath,omitempty"`
	RecordSizeKiB       int32  `json:"RecordSizeKiB,omitempty"`
	CopyTagsToSnapshots bool   `json:"CopyTagsToSnapshots"`
	ReadOnly            bool   `json:"ReadOnly"`
}

OpenZFSVolumeConfiguration is the OpenZFS-specific block on Volume (types.OpenZFSVolumeConfiguration, fsx@v1.68.4 types/types.go). The AWS provider's FindOpenZFSVolumeByID helper treats a Volume response with no OpenZFSConfiguration as an empty result, so every OpenZFS volume -- root or user-created -- must carry one. Only the fields real AWS sets by default on an unconfigured volume are modeled (DataCompressionType/RecordSizeKiB/ CopyTagsToSnapshots/ReadOnly/VolumePath); NfsExports, quotas, snapshot origin, and copy-strategy fields stay a disclosed, unmodeled gap.

type Provider 

type Provider struct{}

Provider implements service.Provider for Amazon FSx.

func (*Provider) Init 

func (p *Provider) Init(ctx *service.AppContext) (service.Registerable, error)

Init initializes the FSx service backend and handler.

func (*Provider) Name 

func (p *Provider) Name() string

Name returns the provider name.

type ReleaseConfiguration 

type ReleaseConfiguration struct {
	DurationSinceLastAccess *DurationSinceLastAccess `json:"DurationSinceLastAccess,omitempty"`
}

ReleaseConfiguration selects the files a RELEASE_DATA_FROM_FILESYSTEM task releases.

type S3AccessPoint 

type S3AccessPoint struct {
	Alias       string `json:"Alias,omitempty"`
	ResourceARN string `json:"ResourceARN,omitempty"`
}

S3AccessPoint mirrors types.S3AccessPoint (the nested details block, a DIFFERENT Go/wire type from S3AccessPointAttachment above), which only has Alias/ResourceARN/VpcConfiguration (deserializers.go:13775).

type S3AccessPointAttachment added in v1.5.0 

type S3AccessPointAttachment struct {
	CreationTime         epochTime                          `json:"CreationTime"`
	OntapConfiguration   *S3AccessPointOntapConfiguration   `json:"OntapConfiguration,omitempty"`
	OpenZFSConfiguration *S3AccessPointOpenZFSConfiguration `json:"OpenZFSConfiguration,omitempty"`
	S3AccessPoint        *S3AccessPoint                     `json:"S3AccessPoint,omitempty"`
	Name                 string                             `json:"Name"`
	Lifecycle            string                             `json:"Lifecycle"`
	Type                 string                             `json:"Type"`
}

S3AccessPointAttachment represents an FSx S3 access point attachment (CreateAndAttachS3AccessPoint / DescribeS3AccessPointAttachments response shape; types.S3AccessPointAttachment, types/types.go:3898). Real AWS has no top-level FileSystemId, VolumeId, ResourceARN, or Tags member here: the attached VolumeId lives under whichever of OntapConfiguration/ OpenZFSConfiguration matches Type, and the ARN/alias live under the nested S3AccessPoint (deserializers.go:13829, case list confirmed against the op's own live deserializer -- no case "Tags" exists on this type at all). CreationTime is first so its non-pointer prefix reduces GC pointer bytes.

type S3AccessPointOntapConfiguration added in v1.5.0 

type S3AccessPointOntapConfiguration struct {
	VolumeID string `json:"VolumeId,omitempty"`
}

S3AccessPointOntapConfiguration is the ONTAP-attached half of an S3AccessPointAttachment (types.S3AccessPointOntapConfiguration, types/types.go:3956): the only member this backend populates is VolumeId (FileSystemIdentity is an input-only echo AWS doesn't return here).

type S3AccessPointOpenZFSConfiguration added in v1.5.0 

type S3AccessPointOpenZFSConfiguration struct {
	VolumeID string `json:"VolumeId,omitempty"`
}

S3AccessPointOpenZFSConfiguration is the OpenZFS-attached half of an S3AccessPointAttachment (types.S3AccessPointOpenZFSConfiguration, types/types.go:3970).

type SharedVpcConfiguration 

type SharedVpcConfiguration struct {
	EnableFsxRouteTableUpdatesFromParticipantAccounts string `json:"EnableFsxRouteTableUpdatesFromParticipantAccounts"`
}

SharedVpcConfiguration holds whether participant accounts can update route tables for FSx for ONTAP Multi-AZ file systems in shared subnets.

type Snapshot 

type Snapshot struct {
	CreationTime epochTime `json:"CreationTime"`
	SnapshotID   string    `json:"SnapshotId"`
	VolumeID     string    `json:"VolumeId"`
	Name         string    `json:"Name"`
	Lifecycle    string    `json:"Lifecycle"`
	ResourceARN  string    `json:"ResourceARN"`
	Tags         []Tag     `json:"Tags,omitempty"`
}

Snapshot represents an FSx ONTAP or OpenZFS snapshot. CreationTime is first so its non-pointer prefix reduces GC pointer bytes. CreationTime uses epochTime: the real FSx deserializer requires a JSON number of epoch seconds here, not an RFC3339 string.

type StorageBackend 

type StorageBackend interface {
	CreateFileSystem(input *createFileSystemInput) (*FileSystem, error)
	DescribeFileSystems(ids []string, maxResults int32, nextToken string) ([]*FileSystem, string, error)
	DeleteFileSystem(in *deleteFileSystemInput) (*deleteFileSystemOutput, error)
	UpdateFileSystem(input *updateFileSystemInput) (*FileSystem, error)

	CreateBackup(input *createBackupInput) (*Backup, error)
	DescribeBackups(
		backupIDs []string,
		filters []wireFilter,
		maxResults int32,
		nextToken string,
	) ([]*Backup, string, error)
	DeleteBackup(backupID string) error
	CopyBackup(input *copyBackupInput) (*Backup, error)

	CreateFileSystemFromBackup(input *createFileSystemFromBackupInput) (*FileSystem, error)

	AssociateFileSystemAliases(fileSystemID string, aliases []string) ([]FileSystemAlias, error)
	DisassociateFileSystemAliases(fileSystemID string, aliases []string) ([]FileSystemAlias, error)
	DescribeFileSystemAliases(
		fileSystemID string,
		maxResults int32,
		nextToken string,
	) ([]FileSystemAlias, string, error)

	CreateDataRepositoryAssociation(input *createDataRepositoryAssociationInput) (*DataRepositoryAssociation, error)
	DeleteDataRepositoryAssociation(associationID string) error
	DescribeDataRepositoryAssociations(
		ids []string,
		filters []wireFilter,
		maxResults int32,
		nextToken string,
	) ([]*DataRepositoryAssociation, string, error)
	UpdateDataRepositoryAssociation(input *updateDataRepositoryAssociationInput) (*DataRepositoryAssociation, error)

	CancelDataRepositoryTask(taskID string) error
	CreateDataRepositoryTask(input *createDataRepositoryTaskInput) (*DataRepositoryTask, error)
	DescribeDataRepositoryTasks(
		ids []string,
		filters []wireFilter,
		maxResults int32,
		nextToken string,
	) ([]*DataRepositoryTask, string, error)

	CreateFileCache(input *createFileCacheInput) (*FileCacheCreating, error)
	DeleteFileCache(fileCacheID string) error
	DescribeFileCaches(ids []string, maxResults int32, nextToken string) ([]*FileCache, string, error)
	UpdateFileCache(input *updateFileCacheInput) (*FileCache, error)

	CreateSnapshot(input *createSnapshotInput) (*Snapshot, error)
	DeleteSnapshot(snapshotID string) error
	DescribeSnapshots(
		ids []string,
		filters []wireFilter,
		maxResults int32,
		nextToken string,
	) ([]*Snapshot, string, error)
	UpdateSnapshot(input *updateSnapshotInput) (*Snapshot, error)
	CopySnapshotAndUpdateVolume(input *copySnapshotAndUpdateVolumeInput) (*Volume, error)

	CreateStorageVirtualMachine(input *createStorageVirtualMachineInput) (*StorageVirtualMachine, error)
	DeleteStorageVirtualMachine(svmID string) error
	DescribeStorageVirtualMachines(
		ids []string,
		filters []wireFilter,
		maxResults int32,
		nextToken string,
	) ([]*StorageVirtualMachine, string, error)
	UpdateStorageVirtualMachine(input *updateStorageVirtualMachineInput) (*StorageVirtualMachine, error)

	CreateVolume(input *createVolumeInput) (*Volume, error)
	CreateVolumeFromBackup(input *createVolumeFromBackupInput) (*Volume, error)
	DeleteVolume(in *deleteVolumeInput) (*deleteVolumeOutput, error)
	DescribeVolumes(
		ids []string,
		filters []wireFilter,
		maxResults int32,
		nextToken string,
	) ([]*Volume, string, error)
	RestoreVolumeFromSnapshot(input *restoreVolumeFromSnapshotInput) (*Volume, error)
	UpdateVolume(input *updateVolumeInput) (*Volume, error)

	CreateAndAttachS3AccessPoint(input *createAndAttachS3AccessPointInput) (*S3AccessPointAttachment, error)
	DetachAndDeleteS3AccessPoint(name string) error
	DescribeS3AccessPointAttachments(
		names []string,
		filters []wireFilter,
		maxResults int32,
		nextToken string,
	) ([]*S3AccessPointAttachment, string, error)

	DescribeSharedVpcConfiguration() (*SharedVpcConfiguration, error)
	UpdateSharedVpcConfiguration(input *updateSharedVpcConfigurationInput) (*SharedVpcConfiguration, error)

	ReleaseFileSystemNfsV3Locks(fileSystemID string) error
	StartMisconfiguredStateRecovery(fileSystemID string) error

	TagResource(resourceARN string, tags []Tag) error
	UntagResource(resourceARN string, tagKeys []string) error
	ListTagsForResource(resourceARN string) ([]Tag, error)

	AccountID() string
	Region() string
	Reset()
	Snapshot(ctx context.Context) []byte
	Restore(ctx context.Context, data []byte) error
}

StorageBackend is the interface for FSx storage operations.

type StorageVirtualMachine 

type StorageVirtualMachine struct {
	CreationTime            epochTime `json:"CreationTime"`
	StorageVirtualMachineID string    `json:"StorageVirtualMachineId"`
	FileSystemID            string    `json:"FileSystemId"`
	Name                    string    `json:"Name"`
	Lifecycle               string    `json:"Lifecycle"`
	ResourceARN             string    `json:"ResourceARN"`
	Subtype                 string    `json:"Subtype,omitempty"`
	RootVolumeSecurityStyle string    `json:"RootVolumeSecurityStyle,omitempty"`
	Tags                    []Tag     `json:"Tags,omitempty"`
}

StorageVirtualMachine represents an FSx ONTAP Storage Virtual Machine. CreationTime is first so its non-pointer prefix reduces GC pointer bytes. CreationTime uses epochTime: the real FSx deserializer requires a JSON number of epoch seconds here, not an RFC3339 string.

type Tag 

type Tag struct {
	Key   string `json:"Key"`
	Value string `json:"Value"`
}

Tag is a key-value pair attached to an FSx resource.

type Volume 

type Volume struct {
	CreationTime         epochTime                   `json:"CreationTime"`
	OntapConfiguration   *OntapVolumeConfiguration   `json:"OntapConfiguration,omitempty"`
	OpenZFSConfiguration *OpenZFSVolumeConfiguration `json:"OpenZFSConfiguration,omitempty"`
	VolumeID             string                      `json:"VolumeId"`
	VolumeType           string                      `json:"VolumeType"`
	FileSystemID         string                      `json:"FileSystemId"`
	Name                 string                      `json:"Name"`
	Lifecycle            string                      `json:"Lifecycle"`
	ResourceARN          string                      `json:"ResourceARN"`
	Tags                 []Tag                       `json:"Tags,omitempty"`
}

Volume represents an FSx ONTAP or OpenZFS volume. CreationTime is first so its non-pointer prefix reduces GC pointer bytes. CreationTime uses epochTime: the real FSx deserializer requires a JSON number of epoch seconds here, not an RFC3339 string. Real types.Volume (fsx@v1.68.4 types/types.go) has NO top-level StorageVirtualMachineId member at all -- it lives nested under OntapConfiguration. StorageVirtualMachineId (deserializers.go:12447 case "StorageVirtualMachineId"), confirmed via the live per-op deserializer (deserializers.go:15307's Volume case switch has no top-level case for it). A prior pass emitted it as a fabricated top-level key, which any real typed SDK client silently drops, leaving a volume's SVM association permanently unreadable through every op that returns a Volume.

type WindowsConfiguration added in v1.2.0 

type WindowsConfiguration struct {
	ActiveDirectoryID             string            `json:"ActiveDirectoryId,omitempty"`
	DailyAutomaticBackupStartTime string            `json:"DailyAutomaticBackupStartTime,omitempty"`
	DeploymentType                string            `json:"DeploymentType,omitempty"`
	PreferredSubnetID             string            `json:"PreferredSubnetId,omitempty"`
	RemoteAdministrationEndpoint  string            `json:"RemoteAdministrationEndpoint,omitempty"`
	WeeklyMaintenanceStartTime    string            `json:"WeeklyMaintenanceStartTime,omitempty"`
	Aliases                       []FileSystemAlias `json:"Aliases,omitempty"`
	AutomaticBackupRetentionDays  int32             `json:"AutomaticBackupRetentionDays,omitempty"`
	ThroughputCapacity            int32             `json:"ThroughputCapacity,omitempty"`
	CopyTagsToBackups             bool              `json:"CopyTagsToBackups,omitempty"`
}

WindowsConfiguration describes the Windows-specific configuration of an FSx file system. Real AWS always returns this block for WINDOWS file systems, with at least ThroughputCapacity and DeploymentType populated. Aliases is not populated here: the source of truth for associated DNS aliases is DescribeFileSystemAliases (see AssociateFileSystemAliases / DisassociateFileSystemAliases in file_systems.go), which every client this emulator targets already calls directly rather than reading this convenience mirror.

Source Files

View all Source files

Jump to

Keyboard shortcuts

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