discover

Documentation

Index

• type Config
• type Device
• type Discover
  • func Merge(d ...Discover) Discover
  • func NewCharDeviceDiscoverer(logger *logrus.Logger, devices []string, root string) Discover
  • func NewCreateSymlinksHook(logger *logrus.Logger, csvFiles []string, mounts Discover, cfg *Config) (Discover, error)
  • func NewDeviceDiscoverer(logger *logrus.Logger, locator lookup.Locator, root string, devices []string) Discover
  • func NewFromCSVFiles(logger *logrus.Logger, files []string, root string) (Discover, error)
  • func NewGDSDiscoverer(logger *logrus.Logger, root string) (Discover, error)
  • func NewGraphicsDiscoverer(logger *logrus.Logger, devices image.VisibleDevices, cfg *Config) (Discover, error)
  • func NewGraphicsMountsDiscoverer(logger *logrus.Logger, root string) (Discover, error)
  • func NewLDCacheUpdateHook(logger *logrus.Logger, mounts Discover, cfg *Config) (Discover, error)
  • func NewMOFEDDiscoverer(logger *logrus.Logger, root string) (Discover, error)
  • func NewMounts(logger *logrus.Logger, lookup lookup.Locator, root string, required []string) 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 Filter
• type Hook
  • func CreateLDCacheUpdateHook(logger *logrus.Logger, lookup lookup.Locator, executable string, ...) Hook
  • func CreateNvidiaCTKHook(logger *logrus.Logger, lookup lookup.Locator, executable string, ...) 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 {
	HostPath string
	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 Merge

func Merge(d ...Discover) Discover

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

func NewCharDeviceDiscoverer

func NewCharDeviceDiscoverer(logger *logrus.Logger, devices []string, root string) Discover

NewCharDeviceDiscoverer creates a discoverer which locates the specified set of device nodes.

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 NewDeviceDiscoverer

func NewDeviceDiscoverer(logger *logrus.Logger, locator lookup.Locator, root string, devices []string) Discover

NewDeviceDiscoverer creates a discoverer which locates the specified set of device nodes using the specified locator.

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 NewGDSDiscoverer

func NewGDSDiscoverer(logger *logrus.Logger, root string) (Discover, error)

NewGDSDiscoverer creates a discoverer for GPUDirect Storage devices and mounts.

func NewGraphicsDiscoverer

func NewGraphicsDiscoverer(logger *logrus.Logger, devices image.VisibleDevices, cfg *Config) (Discover, error)

NewGraphicsDiscoverer returns the discoverer for graphics tools such as Vulkan.

func NewGraphicsMountsDiscoverer

func NewGraphicsMountsDiscoverer(logger *logrus.Logger, root string) (Discover, error)

NewGraphicsMountsDiscoverer creates a discoverer for the mounts required by graphics tools such as vulkan.

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 NewMOFEDDiscoverer

func NewMOFEDDiscoverer(logger *logrus.Logger, root string) (Discover, error)

NewMOFEDDiscoverer creates a discoverer for MOFED devices.

func NewMounts

func NewMounts(logger *logrus.Logger, lookup lookup.Locator, root string, required []string) Discover

NewMounts creates a discoverer for the required mounts using the specified locator.

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 Filter

type Filter interface {
	DeviceIsSelected(device Device) bool
}

Filter defines an interface for filtering discovered entities

type Hook

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

Hook represents a discovered hook.

func CreateLDCacheUpdateHook

func CreateLDCacheUpdateHook(logger *logrus.Logger, lookup lookup.Locator, executable string, defaultPath string, libraries []string) Hook

CreateLDCacheUpdateHook locates the NVIDIA Container Toolkit CLI and creates a hook for updating the LD Cache

func CreateNvidiaCTKHook

func CreateNvidiaCTKHook(logger *logrus.Logger, lookup lookup.Locator, executable string, defaultPath string, hookName string, additionalArgs ...string) Hook

CreateNvidiaCTKHook creates a hook which invokes the NVIDIA Container CLI hook subcommand.

type Mount

type Mount struct {
	HostPath string
	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