bmc

type BMCResetter interface {
	BmcReset(ctx context.Context, resetType string) (ok bool, err error)
}

type BiosConfigurationGetter interface {
	GetBiosConfiguration(ctx context.Context) (biosConfig map[string]string, err error)
}

type BiosConfigurationResetter interface {
	ResetBiosConfiguration(ctx context.Context) (err error)
}

type BiosConfigurationSetter interface {
	SetBiosConfiguration(ctx context.Context, biosConfig map[string]string) (err error)
}

type BootDeviceOverride struct {
	IsPersistent bool
	IsEFIBoot    bool
	Device       BootDeviceType
}

type BootDeviceOverrideGetter interface {
	BootDeviceOverrideGet(ctx context.Context) (override BootDeviceOverride, err error)
}

type BootDeviceSetter interface {
	BootDeviceSet(ctx context.Context, bootDevice string, setPersistent, efiBoot bool) (ok bool, err error)
}

type BootDeviceType string

type Closer interface {
	Close(ctx context.Context) error
}

type FirmwareInstallProvider interface {
	// FirmwareInstallUploadAndInitiate uploads _and_ initiates the firmware install process.
	//
	// return values:
	// taskID - A taskID is returned if the update process on the BMC returns an identifier for the update process.
	FirmwareInstallUploadAndInitiate(ctx context.Context, component string, file *os.File) (taskID string, err error)
}

type FirmwareInstallStepsGetter interface {
	FirmwareInstallSteps(ctx context.Context, component string) ([]constants.FirmwareInstallStep, error)
}

type FirmwareInstallVerifier interface {
	// FirmwareInstallStatus returns the status of the firmware install process.
	//
	// parameters:
	// installVersion (required) - the version this method should check is installed.
	// component (optional) - the component slug for the component update being installed.
	// taskID (optional) - the task identifier.
	//
	// return values:
	// status - returns one of the FirmwareInstall statuses (see devices/constants.go).
	FirmwareInstallStatus(ctx context.Context, installVersion, component, taskID string) (status string, err error)
}

type FirmwareInstaller interface {
	// FirmwareInstall uploads firmware update payload to the BMC returning the task ID
	//
	// parameters:
	// component - the component slug for the component update being installed.
	// operationsApplyTime - one of the OperationApplyTime constants
	// forceInstall - purge the install task queued/scheduled firmware install BMC task (if any).
	// reader - the io.reader to the firmware update file.
	//
	// return values:
	// taskID - A taskID is returned if the update process on the BMC returns an identifier for the update process.
	FirmwareInstall(ctx context.Context, component string, operationApplyTime string, forceInstall bool, reader io.Reader) (taskID string, err error)
}

type FirmwareInstallerUploaded interface {
	// FirmwareInstallUploaded uploads firmware update payload to the BMC returning the firmware install task ID
	//
	// parameters:
	// component - the component slug for the component update being installed.
	// uploadTaskID - the taskID for the firmware upload verify task (returned by FirmwareUpload)
	//
	// return values:
	// installTaskID - A installTaskID is returned if the update process on the BMC returns an identifier for the firmware install process.
	FirmwareInstallUploaded(ctx context.Context, component, uploadTaskID string) (taskID string, err error)
}

type FirmwareTaskVerifier interface {
	// FirmwareTaskStatus returns the status of the firmware upload process.
	//
	// parameters:
	// kind (required) - The FirmwareInstallStep
	// component (optional) - the component slug for the component that the firmware was uploaded for.
	// taskID (required) - the task identifier.
	// installVersion (optional) -  the firmware version being installed as part of the task if applicable.
	//
	// return values:
	// state - returns one of the FirmwareTask statuses (see devices/constants.go).
	// status - returns firmware task progress or other arbitrary task information.
	FirmwareTaskStatus(ctx context.Context, kind bconsts.FirmwareInstallStep, component, taskID, installVersion string) (state constants.TaskState, status string, err error)
}

type FirmwareUploader interface {
	FirmwareUpload(ctx context.Context, component string, file *os.File) (uploadVerifyTaskID string, err error)
}

type FloppyImageMounter interface {
	MountFloppyImage(ctx context.Context, image io.Reader) (err error)
}

type FloppyImageUnmounter interface {
	UnmountFloppyImage(ctx context.Context) (err error)
}

type InventoryGetter interface {
	Inventory(ctx context.Context) (device *common.Device, err error)
}

type Metadata struct {
	// SuccessfulProvider is the name of the provider that successfully executed
	SuccessfulProvider string
	// ProvidersAttempted is a slice of all providers that were attempt to execute
	ProvidersAttempted []string
	// SuccessfulOpenConns is a slice of provider names that were opened successfully
	SuccessfulOpenConns []string
	// SuccessfulCloseConns is a slice of provider names that were closed successfully
	SuccessfulCloseConns []string
	// FailedProviderDetail holds the failed providers error messages for called methods
	FailedProviderDetail map[string]string
}

type NMISender interface {
	SendNMI(ctx context.Context) error
}

type Opener interface {
	Open(ctx context.Context) error
}

type PostCodeGetter interface {
	// PostCode retrieves the BIOS/UEFI POST code from a device
	//
	// returns 'status' which is a (bmclib specific) string identifier for the POST code
	// and 'code' with the actual POST code returned to bmclib by the device
	PostCode(ctx context.Context) (status string, code int, err error)
}

type PowerSetter interface {
	// PowerSet sets the power state of a Machine through a BMC.
	// While the state's accepted are ultimately up to what the implementation
	// expects, implementations should generally try to provide support for the following
	// states, modeled after the functionality available in `ipmitool chassis power`.
	//
	// "on": Power up chassis. should not error if the machine is already on
	// "off": Hard powers down chassis. should not error if the machine is already off
	// "soft": Initiate a soft-shutdown of OS via ACPI.
	// "reset": soft down and then power on. simulates a reboot from the host OS.
	// "cycle": hard power down followed by a power on. simulates pressing a power button
	// to turn the machine off then pressing the button again to turn it on.
	PowerSet(ctx context.Context, state string) (ok bool, err error)
}

type PowerStateGetter interface {
	PowerStateGet(ctx context.Context) (state string, err error)
}

type Provider interface {
	// Name of the provider
	Name() string
}

type SOLDeactivator interface {
	DeactivateSOL(ctx context.Context) (err error)
}

type ScreenshotGetter interface {
	Screenshot(ctx context.Context) (image []byte, fileType string, err error)
}

type SystemEventLog interface {
	ClearSystemEventLog(ctx context.Context) (err error)
	GetSystemEventLog(ctx context.Context) (entries [][]string, err error)
	GetSystemEventLogRaw(ctx context.Context) (eventlog string, err error)
}

type SystemEventLogEntries [][]string

type UserCreator interface {
	UserCreate(ctx context.Context, user, pass, role string) (ok bool, err error)
}

type UserDeleter interface {
	UserDelete(ctx context.Context, user string) (ok bool, err error)
}

type UserReader interface {
	UserRead(ctx context.Context) (users []map[string]string, err error)
}

type UserUpdater interface {
	UserUpdate(ctx context.Context, user, pass, role string) (ok bool, err error)
}

type VirtualMediaSetter interface {
	SetVirtualMedia(ctx context.Context, kind string, mediaURL string) (ok bool, err error)
}