migration

type BackupSchedule struct {
	// Name of the backup schedule.
	Name string
	// Schedule is defined as a cron expression.
	Schedule string
}

type Component struct {
	// Name holds the component name.
	Name string
	// Version holds the component version.
	Version string
}

type Configuration struct {
	// GlobalConfig is the global configuration of the exporter system.
	GlobalConfig GlobalConfig
	// DoguConfigs is the configuration of all installed dogus in the exporter system.
	DoguConfigs []DoguConfig
	// BackupSchedules is the configuration of all backup schedules in the exporter system.
	BackupSchedules []BackupSchedule
}

type Dogu struct {
	// Name holds the dogu name including the namespace delimited by a slash ("/").
	Name string
	// Version holds the dogu version.
	Version string
	// Volume contains data on the dogu's persistent storage.
	Volume DoguVolume
}

type DoguConfig struct {
	// Name of the dogu.
	Name string
	// NormalConfig normal dogu configuration as KeyValue pairs
	NormalConfig []KeyValue
	// LocalConfig local dogu configuration as KeyValue pairs
	LocalConfig []KeyValue
	// SensitiveConfig sensitive dogu configuration as KeyValue pairs
	SensitiveConfig []KeyValue
}

type DoguExport struct {
	// Dogu specifies the name of the Dogu to be exported.
	Dogu string
	// VolumePath specifies the file system path to the volume associated with the Dogu being exported.
	VolumePath string
	// ExporterPort defines the network port used by the exporter process for transferring data.
	ExporterPort int
}

type DoguStarter interface {
	StartAll(ctx context.Context) error
}

type DoguStopper interface {
	StopAll(ctx context.Context) error
}

type DoguVolume struct {
	// SizeInBytes contains the expected dogu volume size.
	//
	// While int32 (~2 Gibi bytes) is too small for comfort, int64 (~9 Exbi bytes) should suffice to accommodate the
	// size of even the largest dogu volume.
	SizeInBytes int64
}

type DoguVolumeResizer interface {
	ResizeDogusIfNeeded(ctx context.Context, exporterDogus []Dogu, importerDogus []Dogu) error
}

type ExportModeValidator interface {
	Validate(ctx context.Context) error
}

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

type FinalTimestamp time.Time

type GlobalConfig []KeyValue

type JobProviderDependencies struct {
	JobContainerConfig configuration.JobContainer
	SSHConfig          configuration.SSH
	APIKey             string
	DoguVolumeBasePath string
	PVCClient          pvcClient
}

type JobRunner interface {
	Run(ctx context.Context) error
}

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

type JobServiceDependencies struct {
	JobProviderDependencies
	JobClient jobClient
	PodClient podClient
}

type KeyValue struct {
	// Key is the name of the configuration value.
	Key string
	// Value is the value of the configuration value.
	Value string
}

type LogInitializer interface {
	InitializeWithLogFile() error
}

type MailSender interface {
	Send(ctx context.Context, isFinal bool, migrationResult error, startTime time.Time, endTime time.Time) error
}

type MaintenanceModeHandler interface {
	Enable(ctx context.Context) error
	Disable(ctx context.Context) error
}

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

type MigratorDependencies struct {
	ExportModeValidator
	SystemInfoProvider
	SystemInfoValidator
	DoguVolumeResizer
	MaintenanceModeHandler
	MailSender
	LogInitializer
	JobRunner
	DoguStopper
	DoguStarter
}

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

type SystemInfo struct {
	// FQDN contains the DNS name of the exporter systeḿ.
	FQDN string
	// IsMultinode indicates whether the exporter system is a classic CES or a multinode CES instance.
	IsMultinode bool
	// Dogus contains data on all installed dogus on the exporter side.
	Dogus []Dogu
	// Components contain data on all installed components on the exporter side.
	Components []Component
}

type SystemInfoProvider interface {
	GetExporterSystemInfo(ctx context.Context) (*SystemInfo, error)
	GetImporterSystemInfo(ctx context.Context) (*SystemInfo, error)
}

type SystemInfoValidator interface {
	Validate(ctx context.Context, exporterInfo *SystemInfo, importerInfo *SystemInfo) error
}