discover

Documentation

Index

• type Config
• type Device
• type Discover
  • func NewCreateSymlinksHook(logger *logrus.Logger, csvFiles []string, mounts Discover, cfg *Config) (Discover, error)
  • func NewFromCSVFile(logger *logrus.Logger, locators map[csv.MountSpecType]lookup.Locator, ...) (Discover, error)
  • func NewFromCSVFiles(logger *logrus.Logger, files []string, root string) (Discover, error)
  • func NewLDCacheUpdateHook(logger *logrus.Logger, mounts Discover, cfg *Config) (Discover, error)
  • func NewList(d ...Discover) Discover
• type DiscoverMock
  • func (mock *DiscoverMock) Devices() ([]Device, error)
  • func (mock *DiscoverMock) DevicesCalls() []struct{}
  • func (mock *DiscoverMock) Hooks() ([]Hook, error)
  • func (mock *DiscoverMock) HooksCalls() []struct{}
  • func (mock *DiscoverMock) Mounts() ([]Mount, error)
  • func (mock *DiscoverMock) MountsCalls() []struct{}
• type Hook
• type Mount
• type None
  • func (e None) Devices() ([]Device, error)
  • func (e None) Hooks() ([]Hook, error)
  • func (e None) Mounts() ([]Mount, error)

Types

type Config

type Config struct {
	Root                                    string
	NVIDIAContainerToolkitCLIExecutablePath string
}

Config represents the configuration options for discovery

type Device

type Device struct {
	Path string
}

Device represents a discovered character device.

type Discover

type Discover interface {
	Devices() ([]Device, error)
	Mounts() ([]Mount, error)
	Hooks() ([]Hook, error)
}

Discover defines an interface for discovering the devices, mounts, and hooks available on a system

func NewCreateSymlinksHook

func NewCreateSymlinksHook(logger *logrus.Logger, csvFiles []string, mounts Discover, cfg *Config) (Discover, error)

NewCreateSymlinksHook creates a discoverer for a hook that creates required symlinks in the container

func NewFromCSVFile

func NewFromCSVFile(logger *logrus.Logger, locators map[csv.MountSpecType]lookup.Locator, filename string) (Discover, error)

NewFromCSVFile creates a discoverer for the specified CSV file. A logger is also supplied. The constructed discoverer is comprised of a list, with each element in the list being associated with a particular MountSpecType.

func NewFromCSVFiles

func NewFromCSVFiles(logger *logrus.Logger, files []string, root string) (Discover, error)

NewFromCSVFiles creates a discoverer for the specified CSV files. A logger is also supplied. The constructed discoverer is comprised of a list, with each element in the list being associated with a single CSV files.

func NewLDCacheUpdateHook

func NewLDCacheUpdateHook(logger *logrus.Logger, mounts Discover, cfg *Config) (Discover, error)

NewLDCacheUpdateHook creates a discoverer that updates the ldcache for the specified mounts. A logger can also be specified

func NewList

func NewList(d ...Discover) Discover

NewList creates a discoverer that is the composite of a list of discoveres.

type DiscoverMock

type DiscoverMock struct {
	// DevicesFunc mocks the Devices method.
	DevicesFunc func() ([]Device, error)

	// HooksFunc mocks the Hooks method.
	HooksFunc func() ([]Hook, error)

	// MountsFunc mocks the Mounts method.
	MountsFunc func() ([]Mount, error)
	// contains filtered or unexported fields
}

DiscoverMock is a mock implementation of Discover.

func TestSomethingThatUsesDiscover(t *testing.T) {

	// make and configure a mocked Discover
	mockedDiscover := &DiscoverMock{
		DevicesFunc: func() ([]Device, error) {
			panic("mock out the Devices method")
		},
		HooksFunc: func() ([]Hook, error) {
			panic("mock out the Hooks method")
		},
		MountsFunc: func() ([]Mount, error) {
			panic("mock out the Mounts method")
		},
	}

	// use mockedDiscover in code that requires Discover
	// and then make assertions.

}

func (*DiscoverMock) Devices

func (mock *DiscoverMock) Devices() ([]Device, error)

Devices calls DevicesFunc.

func (*DiscoverMock) DevicesCalls

func (mock *DiscoverMock) DevicesCalls() []struct {
}

DevicesCalls gets all the calls that were made to Devices. Check the length with:

len(mockedDiscover.DevicesCalls())

func (*DiscoverMock) Hooks

func (mock *DiscoverMock) Hooks() ([]Hook, error)

Hooks calls HooksFunc.

func (*DiscoverMock) HooksCalls

func (mock *DiscoverMock) HooksCalls() []struct {
}

HooksCalls gets all the calls that were made to Hooks. Check the length with:

len(mockedDiscover.HooksCalls())

func (*DiscoverMock) Mounts

func (mock *DiscoverMock) Mounts() ([]Mount, error)

Mounts calls MountsFunc.

func (*DiscoverMock) MountsCalls

func (mock *DiscoverMock) MountsCalls() []struct {
}

MountsCalls gets all the calls that were made to Mounts. Check the length with:

len(mockedDiscover.MountsCalls())

type Hook

type Hook struct {
	Lifecycle string
	Path      string
	Args      []string
}

Hook represents a discovered hook.

type Mount

type Mount struct {
	Path string
}

Mount represents a discovered mount.

type None

type None struct{}

None is a null discoverer that returns an empty list of devices and mounts.

func (None) Devices

func (e None) Devices() ([]Device, error)

Devices returns an empty list of devices

func (None) Hooks

func (e None) Hooks() ([]Hook, error)

Hooks returns an empty list of hooks

func (None) Mounts

func (e None) Mounts() ([]Mount, error)

Mounts returns an empty list of mounts